On Dusk, the job fires on time.
Same trigger. Same schedule. Nobody watching it closely because nobody ever has to. If a state exists, downstream systems usually see enough of it to move. That’s the muscle memory.
The state settles under Dusk's settlement model Moonlight.
Quiet. Correct. Final.
And a little mean, in the way only a rule can be mean.
The chain knows exactly what happened. The proof exists. Scoped tightly. Bound to the execution that just closed inside the DuskVM. The few parties entitled to see it can open it and move on.
Everyone else can’t.
The automation wakes up anyway.
It reaches for the same fields it always reaches for. It’s not even “asking.” It’s reading. And it comes back empty.... not missing, not null, not errored. Just… nothing where things normally are. Columns the job was built around don’t resolve. Not redacted. Gated. The disclosure scope did what it was supposed to do.
Nothing crashes.
That’s what makes it weird.
No spike. No exception. No stack trace worth reading. The process just pauses mid-flow, waiting for data that isn’t late and isn’t coming. Granting that visibility would mean widening the viewer set beyond what was authorized when the state moved, and that decision already passed.
Someone notices because a follow-up never lands.
No settlement export. No reconciliation ping. No downstream “done” that usually shows up five minutes after close.
Ops opens the dashboard.
Job status: green.
Scheduler log: ran.
Dusk view: finalized.
All three are true.
The gap lives between them.
Someone restarts the job anyway. Habit. Same result. Nothing new. Someone tries it from a different worker node like that changes entitlement. It doesn’t.
The bot isn’t “assuming visibility is free.” It’s doing the practical thing it was trained to do: pull the event, compute the transform, push the next message. But the fields it needs live behind the same disclosure gate as everything else in Moonlight. Execution permission and disclosure permission don’t move together here.
A suggestion drifts into the room.
“Can we expose a summary?”
Expose it to whom. Under which scope. Bound to which execution context. And who signs off that the summary doesn’t leak the very thing the proof was designed to hide.
Nobody answers.
Another idea, slightly louder.
“Run the bot under a service identity.”
Which one. With what Dusk disclosure set. And is anyone comfortable adding an automated actor to the viewer list... one that logs everything and forwards it to three other systems everyone forgot were attached.
The room tightens. Not incident-tense. Architectural-tense.
Because the bot isn’t misbehaving. It’s doing exactly what it was built to do. And Dusk the privacy layer-1 built for regulated finance isn’t misbehaving either. Moonlight is enforcing confidentiality exactly where it said it would: at the moment the state closes, not when tooling wishes it had access.
They just don’t meet.
Someone says, half-joking, half-not:
“Just punch a hole for this path.”
Nobody laughs.
The disclosure boundary was locked when the state moved. There is no “just this once.” There’s no reopening it because automation expected ambient access.
So the system does the only thing it can without violating itself.
It waits.
A human with the right scope opens the confidential view. Reads it. Hesitates. Copies nothing. Writes a smaller message instead—duller, vaguer, technically accurate in a way that feels unsatisfying. Enough to unblock the next step. Not enough to expose what Moonlight on Dusk state settlement lane was meant to keep closed.
It’s slower. It’s brittle. It feels like undoing ten years of automation work.
But the bot keeps waking up on schedule anyway.
Still green.
Still blind.