Odin/docs/hermodr-extraction-plan.md

306 lines
15 KiB
Markdown
Raw Normal View History

Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
# Hermodr Extraction Plan
## Objective
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
Hermodr is the Eve-to-browser lowering bridge. It should resolve providers
through Odin's directory, subscribe to those providers for their state, render
their surfaces to browsers, carry operator intent back to the provider that owns
the consequence, and — new — emit a surface as static bytes for audiences that
are not Verse participants.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
It currently runs its own provider ingress and its own state store instead. This
plan deletes that, moves the daemon into its own repository, and adds static
lowering as a second output mode.
## What Odin is
Odin is a rendezvous organ. It tells you what state is available, what schemas
speak it, and where to reach it. It does not tell you what the state is, and it
is not in the data path.
A provider owns its state and serves it. Odin owns the directory. A consumer
resolves through the directory and then talks to the provider.
Hermodr's command path already works this way. `findProviderCommandRoute` looks
a route up in the catalog and then publishes the command to the provider's own
advertised endpoint. Erycina's surface says the same thing from the other side:
`discoveryOwner: "Odin"`, while `canonicalSurfaceUri` points at
`cultmesh://asgard.starfire.erycina/eve/operator/surface` — Odin tells you where,
you go ask Erycina.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
## Current mechanism
Hermodr lives in Odin as Node inside a Rust repository: `src/hermodr-daemon.cjs`
(1,462 lines), `src/hermodr-state-stream.cjs` (32), `test/hermodr-*.test.cjs`
(191), four PowerShell lifecycle scripts, and a persona avatar. Eve holds the
browser-side consumer at `web/hermodr-provider-catalog.mjs`.
### The intent path is already correct
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
`POST /hermodr/commands/eve` is generic across providers. It resolves a
`cultmesh://` target from the body or from the provider catalog, wraps intent as
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
`gamecult.eve.command.v1`, stamps `publishedBy: "hermodr-browser-lowering"`,
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
publishes to the provider's advertised route, and returns a receipt. Eve's client
passes `commandSink: publishCommandIntent` into the renderer and refuses any
response that is not a correlated `gamecult.eve.command_receipt.v1` in state
`reconciled`.
This path is kept unchanged. It is also the reference for what the state path
should look like.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
### The state path is the defect
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
`main()` constructs an `OdinLivePublicationSource` — an in-process `Map` with a
read side (`latest`, `watch`, `watchLifecycle`) and a write side (`accept`,
`withdraw`). It opens its own provider-session ingress, bound to its own address
with its own session token, and feeds accepted documents into that private
store. `HermodrStateStreamRegistry` watches the store and pushes lifecycle
events to browsers.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
So providers publish their state directly into Hermodr, and Hermodr decides what
it holds. A surface reaches a browser only if its provider binds to Hermodr,
which makes a required ingress out of something named a bridge.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
The class is called `OdinLivePublicationSource` and lives in `src/odin/`. Odin
does not use it. Neither the coordinator nor any Odin test references it, and
the same is true of `provider-session-ingress.cjs`. This is Hermodr's own state
machinery wearing Odin's name and filed under Odin's shared modules, which is
why it reads as though Odin sanctioned it.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
### The loop does not close
The command path was added after the fact, on discovering the original bridge
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
was entirely non-interactive. It was added well, but to one leg only, and the
rest still assumes a viewer.
Intent leaves correctly, to the provider that owns the consequence. The
consequence returns as newly published provider state — and that reaches the
browser only through Hermodr's private ingress. A provider must therefore
publish twice: once wherever the Verse expects it, and once into Hermodr, so the
operator can see their own action land.
The core issue is not a missing write path. Intent goes out the right door and
consequence comes back through the wrong one. Deleting the ingress is what
closes the loop: once state arrives by subscription to the provider, a command's
effect returns by the same route as every other change.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
The client already carries the seed of the static case. `publishCommandIntent`
checks `liveHermodr` and, when absent, logs the intent instead of posting it.
## Invariants
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
- A provider owns its state and serves it. Nothing else holds it as truth.
- Odin owns the directory: what exists, what schema, where. Never the data path.
- Hermodr owns the browser edge: session, transport, lowering, relay of intent.
It holds projections with sequence numbers, never truth.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
- A lowering runtime cannot make something true by rendering it.
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
- Static output carries no back-channel and must not pretend otherwise.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
## Authority map
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
**Owner.** Each provider owns its own state, its surface document, and its
command routes. Odin owns provider discovery, schema awareness, and route
advertisement.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
**Inputs to Hermodr.** Odin's catalog, to resolve providers and routes. Provider
subscriptions, for state. Browser requests.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
**Outputs.** Lowered surfaces; live state streams; typed
`gamecult.eve.command.v1` documents published to provider routes; receipts;
static artifacts.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
**Derived, not owner.** Everything Hermodr holds about provider state is a
projection carrying a sequence number. Its staleness marks are display facts,
not withdrawal decisions.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
**Forbidden writers.** Hermodr may not accept or withdraw a publication. It may
not bind a provider session. It may not author a command as itself. Odin may not
become a state relay; if a consumer can read state *from* Odin, the directory
has become the data path.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
**Shared paths.** State resolution and command routing must use the same
catalog lookup. Live and static lowering must render from the same surface graph
through the same composition primitive; if they diverge visually, the static
path is wrong, not the graph.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
## Intended change
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
1. Delete the ingress and the private store. Hermodr resolves a provider through
the catalog, exactly as the command path already does, and subscribes to that
provider for state.
2. `HermodrStateStreamRegistry` survives untouched. It consumes only
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
`source.forProvider(id).watchLifecycle(schemaId, recordKey, cb)`, which is
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
already a narrow port. Replace what sits behind that port with a provider
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
subscription client and every stream, sequence number, and browser keeps
working.
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
3. Extract the daemon to `GameCult/Hermodr`.
4. Add static lowering as a library with a CLI entry point.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
## Cut line
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
Deleted outright:
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
- the `OdinLivePublicationSource` construction and every write into it
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
- `createProviderSessionIngress`, and the `--provider-session-bind` and
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
`--provider-session-token` options
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
Leaves Odin with Hermodr, because Odin never used it:
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
- `src/odin/live-publication-source.cjs` and
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
`src/odin/provider-session-ingress.cjs`, both referenced only by
`hermodr-daemon.cjs` and `test/hermodr-live-publication.test.cjs`. They are
misfiled Hermodr code, not shared Odin modules. If the subscription client
fully replaces them, they are deleted rather than moved.
- `src/odin/utils.cjs` (68 lines), also Hermodr-only. Copy the handful of
helpers actually used; do not extract a utility library.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
Moved out of Odin, for its own reasons:
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
- `src/odin/idunn-rudp.cjs` (324 lines) follows Idunn to `GameCult/Idunn` as a
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
published health-client contract. Genuinely shared — the coordinator and a
health test use it too — so both consume it from its owner rather than each
carrying a copy.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
Resolved, not copied:
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
- `src/odin/documents.cjs` (536 lines) is the only true shared dependency, used
by the coordinator, Hermodr, and two discovery tests. It survives as a decode
contract and must become a published package. Forking it creates two
definitions of one wire format, which is the failure this plan exists to
remove.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
## Subtraction budget
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
Hermodr loses its ingress and its state store. Odin loses the Node daemon, four
lifecycle scripts, three misfiled Hermodr modules, and `idunn-rudp.cjs`. One
shared document package appears. Net: a duplicate acceptance authority deleted,
`src/odin/` reduced from fourteen modules to ten, one package added, one
repository added.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
The static lowering library is the only genuinely new surface. It earns its keep
by making public storefronts hostable without a mesh, a runtime, or a daemon —
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
the difference between a founding creator being able to self-host and not.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
## Build budget
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
Node only; no Rust targets change. Odin's crates are untouched. The new
repository is one package with a test target, and static lowering adds a CLI
entry to that same package rather than a second package.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
## Phases
**Phase 1 — Idunn RUDP client. Done, as a split.** The transport moved to
CultLib as `cultnet-ts`'s `signed-daemon-health`; Idunn now documents its
connection id and schema names; Odin keeps a 65-line adapter that declares that
contract. The whole-file move originally specified was not carried out, for the
reasons below.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
**Phase 2 — Delete the ingress, in place. Done.** `ProviderSubscriptionSource`
replaces the private store behind the existing port, the ingress and its options
are gone, and `src/odin/` is down to twelve modules. Verified by unit tests;
behaviour against a live provider over RUDP remains an operator step.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
**Phase 3 — Publish the document contract. Done.** The 45 definitions are
`cultcache-ts`'s `defineSwarmDocuments`, verified byte-identical to what
`documents.cjs` produced. Odin keeps a 26-line adapter under the name its
consumers already call. `utils.cjs` left with Hermodr, which used one of its six
functions.
**Phase 4 — Extract. Done.** `GameCult/Hermodr`, MIT, sixteen files. The three
dependencies on Odin were resolved rather than carried: the catalog comes from
CultLib, Idunn's health contract is declared locally over the CultLib transport
with `sourceRuntimeId` `hermodr`, and `parseArgs` is seventeen lines of
`args.cjs`. `src/odin/` is down from fourteen modules to eleven, and Odin's
CommonJS surface from sixteen files to twelve.
**Phase 5 — Static lowering. Done, in `GameCult/Hermodr`.** A library and CLI
rendering a surface graph to standalone HTML through the same renderEveSurface
the browser uses, under jsdom, with command controls disabled and labelled
because a static page has no back-channel. Runnable without the daemon.
All five phases are complete. This document stays here as the record of what
left Odin and why; the work now happens in Hermodr.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
## Verification
Positive:
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
- A provider that publishes only to its own advertised address reaches a browser
through Hermodr. This fails today and is the point of the work.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
- Live state streams keep their sequence numbers, and stale and reconnected
transitions still fire across a provider restart.
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
- A browser command still reaches its provider and returns a correlated receipt.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
- Static output of a surface renders equivalently to the live lowering of the
same graph.
Negative, and these are the ones that prove the authority moved:
- Hermodr cannot be made to accept a provider publication. The code path is
gone, not merely unused.
- Starting Hermodr with the removed ingress options fails loudly rather than
silently ignoring them.
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
- With Odin stopped, Hermodr cannot resolve providers it has not already
resolved, but existing provider subscriptions keep delivering. If stopping
Odin stops live state, Odin is in the data path and this plan failed.
- Nothing reads state *from* Odin. A consumer able to do so proves the directory
became a relay.
- Two Hermodr instances against the same provider show the same state.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
- Static output contains no command controls that appear operable. A dead button
in a static page is a lie about a back-channel that does not exist.
## Why Phase 1 was split rather than moved
Reading `idunn-rudp.cjs` before moving it changed the answer. Of its 324 lines,
13 mention Idunn, and most of those are error message strings. The genuinely
Idunn-owned content is two constants: the connection ID `0x1d0d0001` and the
schema name `idunn.signed_daemon_health.v1`. Everything else — Ed25519 signing,
RUDP session management, packet receipt, endpoint parsing, msgpack framing — is
generic CultNet client plumbing.
Moving the file to Idunn would put 311 lines of transport code into a Rust
repository with no Node packaging, and would give Odin a cross-repo filesystem
dependency on a sibling checkout. The file already resolves CultLib by walking
`__dirname/../../../CultLib`, which works only while Odin sits beside CultLib;
Erycina had the identical bug and it broke the moment that repository moved.
Repeating it deliberately, in the plan whose purpose is removing misplaced
ownership, would be a poor trade.
It also buys nothing yet. The duplication it prevents does not exist until
Hermodr leaves in Phase 4, because both consumers still live in this repository.
Three options, in the order I would rank them:
1. **Generic to CultLib, constants to Idunn.** The transport belongs beside
`cultnet-ts`, which Odin already resolves into and Hermodr will too. Idunn
owns the connection ID and the schema name. This is the real fix, and it
removes the sibling-path bug rather than relocating it.
2. **Defer to Phase 4.** Correct and free. Move it when the duplication actually
threatens, and decide the shape then.
3. **Move it whole to Idunn.** As originally written. Cheapest to type, and it
puts transport code where it does not belong while adding a fragile path.
Option 1 was chosen and carried out. `idunn-rudp.cjs` fell from 324 lines to 65:
Idunn's three constants and the call shapes Odin's consumers already use.
`packages/cultnet-ts/src/signed-daemon-health.ts` holds the transport, taking
the contract as a parameter. Idunn's
`docs/signed-daemon-health-authority.md` gained the wire-contract table it was
missing — the connection id had existed only in this consumer's code.
Both the moved module and the adapter dropped the sibling-path assumption on the
way, honouring `CULTLIB_ROOT` instead of walking up three directories from
wherever the file happens to sit.
Phase 3's remaining decision is unchanged: `documents.cjs` is now the only
genuinely shared dependency left between Odin and a future Hermodr.
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
## Open questions for the operator
1. **`documents.cjs` ownership.** Published from Odin, or promoted into CultLib
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
beside the other typed contracts? It is a wire format several services share,
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
which argues for CultLib, but Odin authors it.
2. **Ephemeral view state.** Expanded panels, unsent field contents, optimistic
Correct the Hermodr plan: Odin is a directory, not a state owner The previous revision assigned provider ingress and live-publication acceptance to Odin, and described Hermodr as a second Odin holding a parallel instance of the same store. Both claims were wrong, and the second was asserted without checking. Odin is a rendezvous organ. It publishes what state is available, what schema speaks it, and where to reach it. It is not in the data path, and it never carried this state: neither odin-coordinator.cjs nor any Odin test references OdinLivePublicationSource or provider-session-ingress.cjs. Those modules are Hermodr's own state machinery wearing Odin's name and filed under src/odin/, which is what made it read as sanctioned. So there is no second Odin. There was never a first one for this state. The cut is not to hand acceptance back to Odin, which does not want it, but to delete it and have Hermodr resolve providers through the catalog and subscribe to them directly. The command path already models this correctly. findProviderCommandRoute looks a route up in the catalog and publishes to the provider's own endpoint, and Erycina's surface names Odin as discoveryOwner while pointing canonicalSurfaceUri at Erycina's own address. The retrofitted leg got the architecture right; the original state leg did not. Dependency picture corrected by actual reference counts. Only documents.cjs and idunn-rudp.cjs are genuinely shared with the coordinator. utils.cjs, live-publication-source.cjs, and provider-session-ingress.cjs are Hermodr-only and leave with it or are deleted, which shrinks src/odin/ from fourteen modules to ten and removes the documents.cjs decision from the critical path of everything else. Negative checks now include the one that matters for the corrected model: with Odin stopped, existing provider subscriptions must keep delivering. If they do not, Odin is in the data path and the plan failed. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:29:27 +02:00
pending states. Client-side today by omission rather than decision.
3. **Static lowering and identity.** A live surface knows who is viewing; a
Plan the Hermodr extraction and authority cut Hermodr is described as the Eve-to-browser lowering bridge. It is also a second provider ingress and a second acceptance authority: main() constructs its own OdinLivePublicationSource, binds its own provider session with its own token, accepts publications into that private Map, and serves them to browsers. Odin's coordinator holds a separate instance over the same providers with no reconciliation. A surface reaches a browser only if its provider binds to Hermodr, which makes a required ingress out of something named a bridge. The intent path is not the problem and is kept as-is. POST /hermodr/commands/eve is generic across providers, wraps intent as gamecult.eve.command.v1, stamps itself as the relay rather than the author, publishes to the provider's advertised route, and returns a receipt. Eve's client dispatches controls through it and refuses anything that is not a correlated receipt in state reconciled. The defect is that the loop does not close. Intent leaves by CultMesh to the owner of the consequence; the consequence returns only through Hermodr's private ingress. A provider must publish twice for the Verse to be correct and for the operator to see their own action land. Cutting the acceptance authority is what closes it: with the state leg subscribed to Odin-accepted state, a command's effect returns by the same route as every other change. The plan orders the work so the authority cut happens in place, before any file moves, because an extraction that carries the split brain into a new repository has only changed its address. Static lowering lands last and as a library with a CLI, since emitting bytes from a graph earns no daemon, and requiring one would reintroduce the dependency static lowering exists to remove. Records five open dependencies, three phases of subtraction, and negative checks that prove the old path can no longer accept, no longer override, and no longer paper over Odin being absent. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-06 18:24:30 +02:00
static artifact does not. Either static surfaces are public-only, or the
lowering takes an audience parameter and emits per-audience artifacts.
Public-only is smaller and covers the storefront.