Nothing in Dungeon now runs a Persona, an operational agent or an elaborator on its own. Deleted from runtime.rs: the cover tick driver (drive_cover_tick, drive_one_tick, run_cover_tick, submit_clock_tick, CoverSummary, InterruptedCell, cover_panel, the clock-tick constants, configured_cover_budget, configured_tick_interval), the Active elaboration sweep (elaborate_world, run_elaboration_sweep, ELABORATION_SWEEP_INTERVAL, configured_elaboration_ceiling, AppState.elaboration_permits), and the owner's "Let X act" route (ControllerActPayload, dispatch_controller, admit_controller_command, ControllerHttpResult and its builders, controller_error_disposition). Deleted from eve.rs: CoverPanel, CoverPanelTick, cover_card, the owner's controller buttons and descriptor, and world.controller.act from operation_schema. AppState.controller_quarantined is deleted as well: its only writers were dispatch_controller and run_cover_tick, so it could never be set again. controller_permits and configured_controller_concurrency stay for Cut 8; until then only runtime_readiness reads the pool. ControllerRunner stays for seeding and custody_probe; world.speak, the story card and world.advance_time stay until Cut 9. Tests dropped with the behaviour they pinned: the nine the cut map lists, plus no_proposal_projection_carries_the_canonical_world_commit, which tested the deleted controller_submission. Their fixtures go with them; the world fixture collapses to the Draft-only path its remaining callers use. removed_legacy_operation_is_denied_before_dispatch now also names world.controller.act. Docs: the MVP doc, the ontology and the handoff drop the cover, tick-interval and elaboration-ceiling variables and the sentences that described the deleted drivers. Library untouched. Built and tested on Windows only. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
60 KiB
Ghostlight World Ontology
Status
This document is the closed typed vocabulary for world structure, character
action, and elaboration, and the deterministic verification that admits all
three. docs/architecture/ghostlight-dungeon-mvp.md remains the authority map:
it owns who may write, what the prime invariants are, and where the boundaries
sit. This document owns what the vocabulary is and what the reducer checks.
It may not introduce a writer, a semantic gate, or a second commit path.
docs/architecture/ghostlight-transition-algebra.md and
docs/architecture/ghostlight-multiresolution-agency.md describe the
pre-rebuild machine and are teardown evidence. Their surviving ideas are named
where they are used: one mutation vocabulary across every admission
lane; compact mutation drafts with a complete deterministic mismatch set; and a
resumable per-jurisdiction elaborator session checkpointed against admitted
commit ancestry.
Objective
One vocabulary and one deterministic verifier for three things that used to be three machines:
- world elaboration — adding structure at a causal boundary;
- character action — a subject changing the world through an affordance;
- institutional flow — obligations, pressures, and authority propagating through layers of collective agency without a narrator.
Verification is structural. The reducer checks reference integrity, preconditions, authority scope, effect ceilings, conservation, and knowledge scope. It never checks whether the result is interesting, plausible, diverse, or well written. Depth comes from typed structure that constrains decisions, not from a model agreeing that the world is deep.
Current mechanism
Passes 1 through 10 of the widening are landed (5e53beb, e99af63,
d2805fe, 0f21a49, dbe176d, cb6a126, 1852ddd, 3ed3868,
8aebfb6, b4d1943). The sealed kernel holds subjects with a label and a
kind (Person | Institution | Population); a positions partition with
Position; entities with container under containment acyclicity; Route
as an EdgeRecord variant carrying AccessKind { Public, Restricted }, a
minute Cost in 1..=525_600, and an open flag; subject-keyed holdings of
Quantity(u64) per entity, absence meaning zero, checked arithmetic with
u128 ledger accumulators; subject-keyed dependencies on
DependencyTarget { Resource, Route, Subject }; and an affordance_catalog
partition of world-authored entries; authority, selection, and
redress partitions; facts, channels, and knowledge partitions;
commitments, pressures, and last_opportunity_at partitions; and the
scalars now and scale_intent. There is no relation yet.
world/patch.rs owns typed SubjectId/EntityId/EdgeId/AffordanceId
namespaces, Ref<Id> with DraftHandle (adjacently tagged RefKind), and a
closed resolve_patch that resolves declarations, then operations, and
returns the complete Vec<Mismatch> before any canonical ID allocates;
derive_id is deterministic over world, command, and handle.
Declaration::Affordance admits a catalog entry with preconditions drawn
only from { Present, Reachable, Holds }, effect ceilings, and weighted
outcome bands. The ten inhabited operations are Relocate, OpenRoute,
CloseRoute, AlterCost, Transfer, Transform (one-to-one), Consume,
Admit (same-patch evidence), Bind, and Release; apply_operations is
the one owner of operation application and conservation, and
patch::check_ledger is the single named conservation check.
CommandBody::AdmitPatch emits WorldEffect::PatchAdmitted through the one
admit_resolved insertion owner shared with genesis; it has no phase gate of
its own, because in Active the answer rule below bounds what a patch may
declare. Before pass 10 the only production author of a WorldPatch is the
elaborator lane, which decodes items one at a time under its draft caps; the
kernel itself bounds a patch nowhere yet. EvidenceRef::new is pub(super)
and its production use is bounded by filter_evidence.
Character action is a precondition-effect transition. Grants are
BTreeMap<DecisionScope, BTreeSet<AffordanceId>>. world/action.rs owns
exercise(), called from reduce and apply_effect: it checks the grant,
evaluates each precondition against the actor's own components at the scope
digest, selects an outcome band from
BandPreimage { world_id, revision, command_id, affordance, band_count }
through digest() with no RNG, bounds the proposed effects by the band's
ceilings, and appends DecisionEvent { band, effects }. Rejections are the
complete ActionMismatch set (17 variants) under
KernelError::ActionRejected. Speak is a kernel-built entry with zero
preconditions and an empty band that carries speech, synthesized only at
genesis. A controller's tools, signatures, and permissions are derived from
its granted entries by catalog_tools, catalog_signatures, and
catalog_permissions; no hand-written permission surface remains.
Authority is a grant of (kind, AuthorityTarget) where the target is a
Subject or a PlaceSubtree; one predicate, covers, decides membership for
the Authorized and HasStanding preconditions, route_admits on
AccessKind::Restricted { requires }, the delegation monotonicity rule, and
the redress projection. Same-kind grants with overlapping targets are rejected
at admission (targets_overlap is structural: identity for subjects,
containment for places, plus a same-revision nesting check between the two
shapes) and verify_state_shape re-checks only the structural rule. An
Office joins an institution to a person; open_office, close_office,
install, and vacate are the selection operations, and an incumbent's
delegated grants are copied into its own ScopeComponents. A Forum admits
petitions from subjects with standing. Authority-writing slots (grant,
revoke) are gated by one rule: the actor's own authority must cover the
target, otherwise ActionMismatch::DelegationNotMonotone.
A Fact is an entity with a Statement and a FactStanding: Canonical
with evidence, or Claimed { by }. Knowledge is subject-keyed per fact with
a Confidence and a KnowledgeSource { Witnessed, Told { by, via }, Seen { by }, Evidenced }; a telling or a showing never overwrites a holder. Witnessed is minted by an authored
patch's AcquireKnowledge and, with no author at all, by Witness (below). A
Channel is an entity with a
Reach { Subjects, Place } and a controller. Speech is an affordance whose
entry declares exactly one Audience { Colocated, Channel }: exercise
mints the Claimed fact through derive_id (one of the fixed set of derive_id
call sites; no pass adds one) and lowers a Communicate whose
recipients are re-derived by one pure fan_out over audience at apply
time. Audience means the declared reach; a channel's controller may broadcast
from outside it (can_broadcast) but receives nothing unless inside it.
Preconditions Knows, CanBroadcast, and CanReach gate at exercise with
ActionMismatch::{FactUnknown, NoAudience, CannotReach}. The statement lives
in facts[fact].statement; the copy inside the committed AssertClaim is
the replay witness and nothing reads it. A visible act is speech's twin with
a different sense: an invocation may carry a display, the actor's own
visible sentence, beside or instead of its utterance, and the kernel lowers
it the same way, an AssertClaim and a Display { actor, fact } whose
recipients are re-derived at apply as everyone standing in the actor's place
(Audience::Colocated, the derivation co-located speech uses), landing
Seen { by } at Believed. The entry's audience is not consulted: a body is
visible to the room whatever the voice addresses, and a display cannot go
down a channel. A speech-carrying entry invoked with a display alone is an
address, not SpeechRequired. Display is lowered by the kernel only and is
in no patch tool: no seed or elaborator moves a person's body from outside
the person, and no field on the operation, the fact, or the knowledge row
carries what the actor meant by it; the reading is the perceiver's own.
WorldSnapshot carries no event
log; the story feed is operator_log, an owner-only projection that the
controller lane cannot name because ControllerRunner holds a
ControllerPort, not the mailbox. WorldMailbox::create declares the genesis
place commons and stands genesis subjects there. Genesis declaration of
consumer subjects is cut ("Elaboration lenses and detail rules"); a consumer declares
its own subjects by owner patch.
Witness is one speakerless event over a place subtree: a beacon, a bell, a
blast. It names a fact, a place, and a confidence, and no speaker at all.
Recipients are never stored; they are derived at apply time by under_place,
the same subtree walk audience's Reach::Place arm uses, so a declared
broadcast area and a witnessed event cannot disagree about who is "under" a
place. Every subject standing anywhere under the place learns the fact;
whoever already holds it is untouched (unheld, the same never-overwrite rule
Communicate's fan-out applies). The landed row is KnowledgeSource::Witnessed
at the authored confidence. A telling still occurred even into an empty room,
so Communicate's empty fan-out is a legal no-op; a witnessed event is only
its reception, so a Witness over an empty subtree — or one where every
standing subject already holds the fact — is refused as
Mismatch::NoOperationEffect at resolve and KernelError::Invariant at apply,
the same rule at both layers. Confinement runs through operation_ground
returning the named place as the whole ground: an elaborator may witness only
under its own jurisdiction root, and a consumer patch may never witness at all,
because PatchGround::Consumer and Jurisdiction(Uncovered) refuse every
place. ComponentOpKind::Witness { confidence } puts the same operation behind
an affordance slot naming [fact, place] roles and no subject role, so a
world-authored affordance can cause a witnessed event with no proposer ever
choosing a speaker. Because every recipient's knows component changes, every
recipient's scope digest moves — nobody else's does — which is what lets a
regional or global event interrupt whoever was mid-thought under that place
(the interruption mechanism of pass 9).
Time is now: FictionalMinutes, moved only by CommandBody::AdvanceTime
from CallerId::System(SystemCapability::Clock); the runtime tick submits
the constant CLOCK_TICK_MINUTES, never a measured duration. world/clock.rs
owns derive_motion, pure over state and tick: routines re-arm by exactly one
period, past-due obligations and goals write Pressure on their subject by
the step table, and an unavailable dependency does the same. A
Commitment is (kind: Routine | Obligation | Goal, counterparty, due, period, checks, statement), created and discharged by two operations, the
statement being what is promised in the promisor's words; Pressure is a
magnitude per source and target with set_pressure as its one writer, zero
spelled by key removal, and three operations (advance, reduce,
resolve). order_opportunities is total: pressure, then time since last
opportunity, then SubjectId. derive_boundaries is pure over state and
yields CausalBoundary::{UnelaboratedDestination, MissingStructure} with a
BoundaryDigest over structure only, never the clock; IndividuationRequired
and PolityInCausalRange are representable and not yet derived.
derive_scale_deficit reads the write-once WorldScaleIntent set at genesis
and counts every subject in exactly one jurisdiction row (Uncovered for a
subject under no root, placed or not). In Active, a patch
that declares or admits evidence must answer a derived boundary or a nonzero
deficit and satisfy it (AnswerRequired, AnswerNotDerived,
AnswerNotSatisfied); a component-only patch answers nothing; Draft answers
nothing.
AdmitPatch has two authors. The owner is unconfined. The elaborator is
CallerId::System(SystemCapability::Elaborator { jurisdiction }), a caller
identity whose only door is WorldMailbox::submit_elaboration; there is no
HTTP ingress for a patch before pass 10. require_patch_author and
confine_to_jurisdiction run in reduce and again in apply_effect: an
elaborator may answer only a boundary or deficit row under its root
(boundaries cover transitively, deficit rows by exact key, so a parent root
cannot answer a child row and double-count it), and may declare places,
relocate, or open routes only inside that root (Mismatch::OutsideJurisdiction,
decided by operation_ground, which is total over ResolvedOp). Placeless
referents (resources, catalog entries, facts) are not confined. The model's
tool surface is PATCH_TOOLS: one tool per non-genesis Declaration and
ComponentOp variant plus two session tools, emitted through
world/tool_schema.rs from one schema spelling per type.
world/elaboration.rs owns the repair loop: a session keyed by a
deterministic command id (sha256 over world, jurisdiction, answer digest)
submits a draft, persists the resolver's complete mismatch set under that id
as a Refusal placed after the rounds that earned it, and continues the same
conversation: the refusal is the next user turn, the model's own calls stay in
view above it so every mismatch site names something it can see, and the draft
is rebuilt from the calls after the refusal. Both authoring lanes share this
fold, bounded by ELABORATION_ROUND_BUDGET and the
MAX_DRAFT_* size caps. Evidence a model cites must come from the round's
EvidenceSource receipts (filter_evidence); with NullEvidenceSource no
canonical fact and no Admit can land from the elaborator lane.
world/cover.rs owns the budgeted connected cover. derive_cover(world, now, tick, opportunities, agency_graph, budget) is pure: it reads the attention
order that order_opportunities owns, reserves the urgency slots for its
head, rotates the remaining subjects through singleton cells by debt, and
packs the rest into grouped cells by connected component of the agency graph
(scheduler-only; reachable from no prompt builder). Cell, Cover,
CellId, Resolution, TickIndex, and AgencyGraph are derived and
disposable; the only durable trace of a tick is the controller_work.v9 row
(ControllerWork::Grouped), custody-separate from world custody. A grouped
cell is one inference over partitioned per-constituent views returning zero
or one attributed proposal per constituent; declines are submitted first and
each proposal commits or is refused on its own scope digest; a coarse
NarrativePersona receives its typed view and does not enter the membrane.
Cell and constituent command ids are sha256-derived.
AdmitPatch has a third author: CallerId::System(SystemCapability::Consumer { consumer }), minted only by WorldMailbox::submit_consumer after the
consumer ingress (world/consumer.rs) has authenticated a document against a
configured secret digest. require_patch_author and confine_to_ground
widen from jurisdiction-only to PatchGround { Jurisdiction(JurisdictionKey), Consumer(ConsumerId) }; a consumer's ground is derived from
controller_assignments at decision time, never carried on the wire, and
confines it to the subjects it controls, with no place, route, or Canonical
fact ever inside that ground. A subject declared
NewController::External { consumer } receives
ControllerAssignment::ExternallyControlled { consumer }: it mints no
controller ID or mode (both accessors are Option), derives no opportunity,
is excluded from agency_graph and the cover, and may hold no affordance
(admit_resolved's controller-shaped pairing rejects a non-empty grant set as
Mismatch::ControllerGrantMismatch). It remains an ordinary subject in the
snapshot, related to and targeted like any other, mutable only through its
own consumer and the always-unconfined world owner. patch::decode_patch is
the one decode bound for both the elaboration lane and the consumer lane,
under four caps — MAX_PATCH_BYTES, MAX_PATCH_DECLARATIONS,
MAX_PATCH_OPERATIONS, MAX_PATCH_EVIDENCE — and the consumer document
travels over two wire schema constants, CONSUMER_PATCH_SCHEMA and
CONSUMER_RECEIPT_SCHEMA, both .v0. The state and commit schemas bump to
ghostlight.world_state.consumer.v2 and ghostlight.world_commit.consumer.v2
(state-schema generation world-v3); a store written under an earlier schema
is refused, not migrated.
WorldScaleIntent now arrives at creation, not as a later admission:
world_create.v4 declares the title, the brief, targets, jurisdiction
roots top-level in the genesis patch beside commons, and the world's lens
weights, which the library requires and never defaults; an invocation
announcing an earlier schema is refused before any handler runs, and the
intent is write-once, set once at genesis and resolved nowhere else. The
brief is the world's authored premise, trimmed at ingress and never
mutated; every lane reads it as its guidance, and a world with an empty
brief gives its lanes none. qualifies is phase-free — a controller, a non-empty
grant set, and a held Goal, checked the same way in Draft and Active — and
the Draft-answer refusal lives only in require_answer, which refuses every
Draft answer regardless of what qualifies says; so a Draft world's deficit
measures what the seed lane has left to author, not a frozen count. The seed
lane (SeedPort's two methods snapshot and submit_seed, SeedRunner,
SeedSession, ControllerWork::Seed, controller_work.v10) admits seed
patches as CallerId::Principal(owner) through the existing unconfined owner
lane, in Draft only: the journal carries no marker distinguishing a
model-authored seed patch from a hand-authored one, because the model is the
owner's Hands during Draft and the owner's ApproveDraft plus ActivateWorld
remain the only path to Active. Evidence for a seed session comes from
VaultEvidenceSource, a read-only markdown directory reader in
world/vault.rs: the reference it hands back is the note's vault-relative
.md path, and its caps (MAX_VAULT_RECEIPTS, MAX_HITS_PER_REFERENT,
MAX_LINK_FANOUT, MAX_EXCERPT_CHARS) bound what one referent can retrieve.
One world.seed invocation runs one session and commits at most one patch
within the existing patch caps, driven by select_row choosing the first
ScaleDeficitRow with a nonzero deficit off the snapshot; prompt_body, the
evidence-and-mismatch tail of an authoring prompt, is shared by both the
elaboration lane and the seed lane so the two cannot drift on what a citation
rule says. One correction against the vocabulary above: a Goal commitment
carries no counterparty and by itself manufactures no MissingStructure
boundary; a commitment with a counterparty does, which is why a seeded
subject's bare goal is exactly the boundary the Active elaborator exists to
answer.
Opportunities bind to a ScopeDigest over one scope_components owner
(controller assignment, grants, delegated grants, own authority, position,
incident routes, own holdings, own dependencies, known fact ids, controlled
channels, own commitments; never now, occupancy, forum state, or another
subject's knowledge); a proposal commits at any later revision with unchanged scope and is
rejected with KernelError::ScopeChanged otherwise. SubjectSnapshot carries
the subject's whole ScopeComponents rather than five duplicate projected
fields; the narrative lane's persisted before-state is those components
frozen at turn time, and the delta shown to the Interpreter on a re-lowering
is the typed component diff against the fresh components plus the
Overheard rows later than the turn's bound revision — never a raw
knowledge row, and never another subject's snapshot. The re-lowering's
provider request is a distinct round (interpreter_round) with its own
content-addressed request id, so it cannot collide with the first lowering's
request. State schema is ghostlight.world_state.consumer.v5, commit schema
ghostlight.world_commit.consumer.v5, controller work controller_work.v16,
Persona turn receipt ghostlight.persona_turn_receipt.v3; earlier stores and
earlier rows are refused. Ghostlight owns a conserved narrative ledger;
Delvehold owns the economy (delvehold-forced-ontology-integration.md).
Step 6 of the plan is complete; the seeded live run is the runbook's business.
Plan step 12 landed the thirteenth row: PersonaMaterial (values, voice,
memories, reads keyed by subject) in its own persona_material partition,
set whole by SetPersonaMaterial with NoncanonicalText for any padded text
or doubled read and NoOperationEffect for identical material; it is read by
projection and by no precondition, so it enters state_digest and no
ScopePreimage. A Commitment carries statement, what is promised in the
promisor's words, required at authoring and derived as "a promise made
through " when an affordance effect creates one.
Rules the road imposed, carried in the tree: the provider request identity is
content-addressed over command, purpose, round, instructions, and input, so a
resumed round replays and a repair round under the same command names a new
request; every tool schema of both authoring lanes satisfies the provider's
strict function-schema rules (anyOf, typed tags, closed objects with every
property required) and a test walks them offline; the seed lane has its own
round budget, asks for several tool calls per response, and submits the draft
as authored when its budget ends; the seed brief prints every canonical id
beside its label and states that a subject counts only if it stands at the
row's root or inside it; the connector's expiry skew bounds an invocation's
validity and a separate response timeout bounds a generation.
The failure this vocabulary is designed against
Run 115 terminated because inst:kharad-road-keepers referenced
loc:kharad-rhythm-road, which did not exist, and four reconciliation steps
could not repair it. Three structural causes, all in the vocabulary:
- Names were keys.
SubjectRef { kind, id: String }accepted a caller-supplied identifier. A plausible string was indistinguishable from a referent until reduction. - Admission was two-phase.
AdmitEntity { initial_components }declared which components a subject could have separately from populating them. A referenceable, empty entity was a legal state. - The batch was flat. Each mutation was permitted independently, so a cross-mutation dangling reference was a runtime discovery. Reconciliation existed to repair that class, which made it a repair loop standing in for an owner.
Depth had the same defect. Texture lived in free strings — posture,
resource_kind, capability_id, persistent_features, description — that
nothing could reason over, so a world with many actors still felt thin. The
answer reached for was model tribunals: the
WorldComplexity*Qualification/*Verification set, a titled semantic
verifier that judged whether each proposal satisfied its titled assignment,
and fixed titled quotas. They were compensators for an ontology with nowhere
to put depth. The eight titles themselves (Patina, Charter, Ledger, Hearth,
Tangle, Veil, Ember, Numen) were lenses, not tribunals. 6bb6869 deleted them
together with their verifier and no operator decision covered them; they
return as the library's stock lens set ("Elaboration lenses and
detail rules").
Character action had a matching defect: an attempt was an event, and a separate wave-level outcome resolver asked a model whether it worked. Resources, relationships, knowledge, and pressures mostly stood still while the prose stayed busy.
The cut: make identity unforgeable, make admission atomic, give depth a typed home, and make an action a typed precondition-effect transition that the same reducer verifies. Then structural admission is sufficient and no verifier, resolver, or reconciler is needed.
Invariants
- A reference is an exact canonical ID issued by the reducer or a draft handle resolved inside the same patch. There is no third form.
- Cross-kind reference is unrepresentable. Typed ID newtypes carry the kind.
- A patch reduces completely or not at all. No canonical ID is issued, revealed, or consumed by a rejected patch.
- Only subjects decide. Places, resources, facts, and channels have no controller, no affordance, and no decision opportunity.
- Custody conserves. Quantity moves or transforms; it is created only by an explicit evidenced admission or an affordance whose effect schema says so.
- Knowledge is scoped. A subject acts only on facts it holds. A patch adds knowledge only by citing an accessible fact or admitting an evidenced one.
- An action is an affordance invocation. Its preconditions are checked against the acting subject's own components at the exact scope digest; its effects cannot exceed the affordance's effect ceiling; an uncertain outcome is selected by kernel-owned entropy from the affordance's declared bands.
- Persona material enriches and never substitutes. Values, voice, memory, and relationship reads cannot stand in for authority, custody, topology, or knowledge.
- Elaboration answers a derived causal boundary, an authored seed request, or an authored scale deficit. Structural validity never waits on a count; liveness is an authored target the elaborators pursue. There is no semantic qualification, round budget, or model-owned completeness verdict.
- A proposal binds to the digest of the components its verification reads, not to the whole world digest. It commits at any later revision where that scope digest is unchanged, and is rejected when it is not.
- Every tool a model may call is a projection of this vocabulary. The tool catalog is derived state and cannot carry an operation the reducer does not own. The expansion rule: the tool surface is exactly the variants a non-genesis patch may carry, with every always-refused choice removed.
Identity
Three namespaces, three newtypes, issued only by the reducer.
SubjectId person, institution, population — can decide
EntityId place, resource, fact, channel — cannot decide
EdgeId route, relation, commitment, pressure — connects the above
Display names are labels. They never resolve a reference or bind structure.
An externally controlled mirror is an ordinary subject of one of these three
kinds; what is external is its ControllerAssignment
(ExternallyControlled { consumer }), not a fourth SubjectKind.
Components
Thirteen, each earning its place by constraining a decision. Some attach to one referent; some are edge-shaped and attach to a pair. The reducer does not care which noun a component is; it cares what it constrains.
| Component | Attaches to | Decision it constrains |
|---|---|---|
Position |
subject → place | who is present, who perceives, who must travel |
Route |
place ↔ place: access, cost | who can arrive in time, who can be cut off |
Custody |
holder → resource: quantity | what can be spent, seized, withheld |
Dependency |
subject → resource, route, or subject | what fails when supply fails |
Authority |
subject → scope: kind | who may legitimately command, tax, judge, admit |
Selection |
office → method, incumbent, term | how power is lost; succession pressure |
Redress |
grievance kind → forum, standing | where conflict goes when it cannot be fought |
Knowledge |
subject → fact: confidence, source | what a subject may act on at all |
Channel |
channel: reach set, controller (latency arrives with the clock, pass 7) | how facts travel; who can be silenced |
Commitment |
subject → counterparty: kind (Routine, Obligation, Goal), due, period, statement |
obligation with a clock; autonomous motion |
Pressure |
source → target: magnitude | the causal boundary trigger |
PersonaMaterial |
subject: values, voice, memories, reads | lived meaning; never authority |
A Fact carries a standing: Canonical (admitted with evidence) or
Claimed { by: SubjectId } (asserted in speech). Knowledge of a claimed fact is
belief. Deception is a subject asserting a claim while holding a contradicting
canonical fact; misread is a listener acquiring a claim the speaker did not
intend. Both are ordinary typed states, not narrator judgments.
Civic order is the Authority + Selection + Redress + Custody subgraph.
It is not a prose manifest and needs no civic verdict. Dependency is the
crisis transmitter: it is what makes a failed pump in one realm a political
problem in another without anyone deciding that it should be.
Component operations
This is the closed operation set. Every mutation the kernel will ever apply is one of these, and every model-facing tool is a projection of one of these.
Declaration declare_subject, declare_place, declare_resource, declare_fact,
declare_channel, declare_route (draft handles only)
Position relocate(subject, via: Route)
Route open, close, alter_cost
Custody transfer(from, to, resource, qty), transform(resource, into, qty),
consume(holder, resource, qty), admit(holder, resource, qty, evidence)
Dependency bind, release
Authority grant(subject, scope, kind), revoke
Selection open_office, close_office, install(office, incumbent), vacate
Redress open_forum(kind, forum, standing), close_forum
Knowledge acquire(subject, fact, source, confidence), communicate(speaker, fact,
channel), witness(fact, place, confidence), forget
Channel set_reach, set_controller
Commitment create(subject, counterparty, kind, due, period, checks, statement), discharge
Pressure advance, reduce, resolve
PersonaMaterial set(subject, values, voice, memories, reads)
Retirement retire(referent, reason)
Time advance(minutes)
Thirty operations. Adding one is a design change to this document and a code change to the reducer; it is never a runtime patch.
Patch construction
One primitive admits structure and effects, in draft and in active play:
WorldPatch
declarations: Vec<Declaration> // new referents, draft handles only
operations: Vec<ComponentOp> // over declared or existing referents
evidence: Vec<EvidenceRef> // exact receipts where a fact is admitted
Ref<Id> = Existing(Id) | Draft(DraftHandle)
Reduction is one pass with no repair step:
- Index every declaration by handle. Duplicate or unused handles reject.
- Resolve every
Ref::Draftagainst that index, checking kind. - Resolve every
Ref::Existingagainst the current revision, checking kind. - Check structural admission over the complete candidate graph.
- Only then allocate canonical IDs and commit atomically.
A rejection returns the complete deterministic mismatch set — every failed
check, not the first — so a proposer repairs one compact draft without
guessing which invariant failed first. inst:kharad-road-keepers naming an
undeclared road is rejected at step 2, before any ID exists. There is nothing
for a reconciler to do, so there is no reconciler.
Structural admission
The reducer checks only these:
- every referent exists or is declared in the same patch;
- containment is acyclic;
- routes have exact place endpoints and a valid cost;
- edge endpoint kinds match the edge kind;
- custody operations conserve declared quantity;
- the deriving authority envelope covers every operation in the patch;
- knowledge additions cite an accessible or newly evidenced fact;
- communication reaches only subjects inside the channel's reach set;
- population slices are disjoint beneath their declared parent;
- an externally controlled subject's components change only through its own
consumer, confined by
PatchGround::Consumer; - the patch produces at least one canonical change.
Interestingness, novelty, political diversity, name quality, prose quality, and counts do not appear here and may not be added.
Affordances: the action vocabulary a world authors
The kernel owns component operations. A world owns its affordance catalog. This is the generality lever: a setting with spellcraft, insurance claims, oath-rhythms, or memetic sovereignty authors affordances from the same thirty operations, and the kernel never learns a genre.
Affordance
kind: AffordanceKind // world-declared name, e.g. Speak, Move, Transfer,
// Decree, Levy, Petition, Cast, Sabotage
preconditions: Vec<Precondition> // over the actor's own components at scope digest
effect_schema: Vec<EffectSlot> // which ComponentOps, on which referent roles,
// within which bounds
outcome_bands: Vec<OutcomeBand> // weighted; each band names its effect subset
Precondition
Present { at: Role } // actor Position matches target place
Reachable { to: Role, within: Cost } // a Route path exists under access and cost
Holds { resource: Role, at_least: Qty } // Custody
Authorized { over: Role, kind } // Authority covers the target scope
HasStanding { forum: Role } // Redress: the forum admits the actor
Knows { fact: Role, at_least: Confidence } // Knowledge
CanBroadcast { via: Audience } // the actor is inside the audience
CanReach { subject: Role, via: Audience } // the subject is inside the audience
Committed { to: Role, kind } // an existing Commitment
Preconditions read only the acting subject's own components and the exact targets the proposal names. A subject cannot act at a distance, spend what it does not hold, command outside its authority, act on a fact it does not know, or speak to someone its channels do not reach. These are checks on typed state, not a model's opinion of feasibility.
Effect slots bound what the invocation may propose: which operations, on which roles, with what magnitude ceiling. A proposal exceeding a slot is rejected. A proposal within its slots is admitted structurally like any patch.
Outcome bands make uncertainty deterministic. When an affordance declares more than one band, the kernel draws from its own committed entropy — seeded by world ID, revision, and command ID — selects one band, and applies only that band's effect subset. The same proposal at the same revision always yields the same band. Neither the Persona, the Interpreter, nor an operational agent can choose success; they choose the attempt.
Speak is the one kernel-built affordance: precondition CanReach, effect
Knowledge.communicate of a Claimed fact to every subject in reach, plus the
speech event. Everything else is authored per world in the seed and may be
extended by elaboration under the same patch primitive.
Action verification
controller proposal (typed, from Interpreter or OperationalAgent)
-> DecisionInvocation { affordance, targets, proposed effects }
-> scope digest check: actor components + named targets unchanged
-> precondition check over those components
-> effect ceiling check against the affordance's slots
-> band selection from kernel entropy
-> lower the band's effects to a WorldPatch
-> structural admission
-> atomic commit; DecisionEvent records affordance, band, and patch digest
Every stage is a pure function of committed state, the proposal, and kernel entropy. A rejection returns the complete mismatch set. Player, NPC, institution, population, import, and elaborator actions share this pipeline; different admission lanes derive different authority envelopes and never different mutations.
Institutional layers and flow
Layers of collective agency are relations, not special subjects:
- Containment nests places and jurisdictions.
- Membership binds persons and slices to institutions and populations.
- Jurisdiction is an
Authoritycomponent whose scope is a subject set or a place subtree. - Representation is
Selection: an institution acts through an office held by a person, so a decree carries an incumbent's name and a succession risk.
An institution normally carries an OperationalAgent controller and authored
affordances such as Decree, Levy, Contract, or Deploy. Their effects
create Commitment on subordinates and counterparties. A due or defaulted
commitment creates or advances Pressure. Unresolved pressure on a subject
becomes that subject's next decision opportunity. That is the whole internal
flow: obligation → pressure → opportunity, propagating along typed relations
with no narrator and no wave planner. A population slice under enough pressure
with no person-shaped subject to bear it derives an IndividuationRequired
boundary.
An institution that also needs a person-shaped public voice gets a separate
NarrativePersona controller on a person subject bound by Selection. Two
controllers, disjoint scopes; awkward overlap is rejected, not resolved by
precedence.
Elaboration
The world grows only where committed state reaches a typed boundary or where an authored seed request opens a scope. Both are answered by the same patch.
CausalBoundary
UnelaboratedDestination { route, place }
PolityInCausalRange { relation, subject }
IndividuationRequired { population, slice, pressure }
MissingStructure { scope } // a commitment or pressure has no authority,
// channel, or redress path that could resolve it
SeedRequest { jurisdiction: DraftHandle, brief: EvidenceRef } // draft phase only;
// representable, not inhabited: Draft answers nothing
Boundaries are derived from a revision exactly as opportunities are, and each carries the digest of the components that derive it. One command answers one:
CommandBody::AdmitPatch { answers: Boundary | SeedRequest, patch: WorldPatch }
A commit clears exactly the boundary it answers. Nothing else clears one. A patch answering a boundary the kernel no longer derives is rejected.
Seed admission is AdmitPatch against an empty draft world under draft
authority. A consumer-authored seed and a compiled seed are the same patch.
There is no seed type, registry, publication handoff, or compiler install path.
Elaborators
An elaborator is one OperationalAgent loop. Two separate things shape a
session. Its jurisdiction is authority: the place subtree it may write in,
carried as SystemCapability::Elaborator { jurisdiction }. Its lens decides
what kind of structure the session reaches for. A lens never enters the caller
identity, never narrows or widens admission, and never fills a quota.
Each sweep builds a claim set of distinct demand entries (every open boundary
once, and one deficit per jurisdiction), held in memory for that sweep and
never persisted. Sessions run concurrently over it, each drawing its lens by
the world's weights (below, "Elaboration lenses and detail rules") and
recording it, each holding one permit of the elaboration ceiling for its whole
step. A sweep first reads the store's in-flight sessions and resumes any that
answer a current demand entry, and the caller runs sweeps one at a time. The
ceiling is the caller's, passed to each sweep; the library holds no
concurrency number. The tool catalog is
generated from this document's operation set and declaration kinds, plus
record_gap and submit. It cannot contain an operation the reducer does not
own, because it is derived from the reducer's vocabulary.
loop:
take one demand entry in my jurisdiction: an open boundary, or my
jurisdiction's scale deficit (seed requests are Draft-only; the Active
sweep does not answer them)
if the store holds an in-flight session answering it, resume that session;
otherwise draw a lens by the world's weights and record it on the session
retrieve evidence for its referents from the world's evidence source; keep
exact receipts (the Active lane binds none yet: `NullEvidenceSource`, L2)
build one WorldPatch with declaration and operation tools
submit; on rejection, repair the same draft from the complete mismatch set
on commit, checkpoint: admitted commit ancestry, open leads, exact rejections
stop when my jurisdiction has no open boundary and no deficit
The scale deficit is derived, not owned. The seed carries a WorldScaleIntent:
a target count of qualified subjects per level (person, institution,
population) and per realm, with realm weights that distribute the target and
never raise it. A subject qualifies structurally: active, one controller, at
least one Goal commitment, at least one executable affordance. The kernel
recounts after every commit and publishes the deficit per jurisdiction as
derived state. Only admitted subjects reduce it; a rejected patch leaves it
visible. Elaborators answering a deficit declare goal-bearing subjects at the
level the deficit names — a person with a want, an office with a mandate, a
slice with a grievance — grounded in evidence like any other patch. Detail
first, then scarcity of attention; that order is what makes actors at every
level pursue their own ends rather than wait to be noticed.
An elaborator session is resumable and checkpointed against admitted commit ancestry; raw conversation is never authority. Elaborators own no fictional truth and no completeness verdict; the target is authored, the count is structural, and the reducer alone admits. One elaborator may fill semantic fields — names, labels, Persona material — inside a typed patch; it is not a Persona, receives no prose membrane, and holds no authority.
Concurrent elaborator sessions do not serialize on one another. A boundary binds to its own scope digest, so a patch answering it commits at any revision where that digest is unchanged; only the mailbox serializes the physical commit. Two elaborators touching overlapping components conflict on scope digest and one repairs.
A translation gap never mints a boundary. Gaps are non-fictional inference evidence that may inform a later human decision to extend this vocabulary, and that extension is a code change, not a world patch.
Elaboration lenses and detail rules (target)
Adopted 2026-09-15. Plan step 15 pass L1 implemented the Lenses and Stock lens
set bullets and the concurrency half of the Sessions bullet. Per-world evidence
binding (L2), detail rules, rule-driven demand and sessions in Draft (L3), and
individuation (L4) are not implemented. These are library capabilities, neutral
to every consumer. A consumer supplies the policy: Ghostlight Dungeon's
Session Zero (ghostlight-session-zero.md) is one consumer of them, and no
consumer's concept enters this vocabulary.
-
Lenses. A world carries weights over the library's lenses as world data. Its creator states them in
CreateWorld(the library holds no default), and the owner replaces them withSetLensWeightsin any phase; a set that weighs the same as the current one is refused asNoCanonicalChange. A lens is a label, brief text, and an ordered emphasis over the operation catalog, carried as instruction text only. Every lens receives the whole derived catalog. A session draws one lens from a digest of its world id and its command id, the kernel'sselect_bandrecipe, so the same session under the same weights draws the same lens; the lens is not part of the command id. The session records the lens and its instruction text on its checkpoint, and a resumed session reads both back and never redraws. The same patch under two lenses has the same admission result. A zero weight never draws; a weight set that cannot draw is refused asLensWeightsNeverDrawat creation and atSetLensWeights. -
Stock lens set. The library ships eight lenses. The set is closed; a consumer chooses among them by weight:
Lens Reaches for Leads with Patina ordinary objects, customs, nicknames, local jokes persona material, ordinary affordances Charter government, law, offices, selection, succession, redress authority, selection, redress Ledger resources, labor, trade, infrastructure, scarcity, class pressure custody, dependency, route cost Hearth kinship, daily life, care, obligation, belonging commitments, reads Tangle factions, alliances, rivalries, leverage relations, pressure, authority Veil secrets, rumors, misinformation, taboos, unevenly held knowledge knowledge scope, channels Ember disputes, hazards, instability, escalation, urgent pressure pressure, near-due commitments Numen religion, magic, ritual, awe, cosmology, the genuinely strange facts, affordances, material -
Detail rules. A world carries one detail rule: a function from place to detail level. A detail level names a target density per place for each subject kind, and the rule carries its own level table. The rule is typed world data, written by the world's creator and changed by its owner through one command, never consumer code: the deficit it produces is an admission input, and replay re-runs
reduce, so a consumer function that changed after admission would make committed history fail replay. Each commit is checked against the rule in force at its revision. The library evaluates a closed, versioned set of forms:Uniform { level }: every place at one level.ByDistance { anchors, bands, floor, lookahead }: anchors are canonical subjects. Distance is the least route cost, in travel minutes, from any anchor's position to a place over open routes that anchor may traverse, reduced bylookahead. It uses the same route walk asreachable, factored to return a cost map. A place without routes takes its nearest routed container's distance. Bands map distance to a level; beyond the last band, and for every place when no anchor is placed, the level isfloor.
A consumer whose rule no form expresses asks for a new form, and the library adds it without consumer names. Combinators wait for a consumer that needs one.
WorldScaleIntentper-kind world targets remain the ceiling the rule distributes; jurisdiction permille is replaced by the rule. -
Demand. Derived in
snapshot, never stored: open boundaries and per-place deficits against each place's level, capped by the remaining world target, ordered by level (most detailed first), then by the form's own key (distance forByDistance), then by the kernel's boundary order. A session's confinement ground is the place subtree of the demand it answers. Under a rule that reads positions, a subject moving changes demand without a commit.IndividuationRequiredderives for a population whose place's level asks for persons. -
Sessions. Up to the caller's elaboration ceiling run at once (L1, in Active). Running in Draft and answering the head of rule-driven demand are not implemented (L3). Each world binds one evidence source, which every session and the seed lane read (L2, not implemented).
Cut when these land: authored jurisdiction roots as confinement units,
permille distribution, the Uncovered deficit row, NullEvidenceSource on
the Active elaborator lane, "Draft answers nothing" for the elaborator lane,
and genesis declaration of any consumer subject.
Verification: the lens-invariant admission test; sampler determinism and
weight-following frequencies; zero-weight refusal; Uniform assigning every
place one level; demand absent from WorldState and reordered by an anchor's
move alone under ByDistance; the world target capping a rule's deficits;
replay of a history spanning a rule change; out-of-ground refusal; Active
patches citing only the bound evidence source; activation with nonzero
deficits.
Scale: many subjects, few inferences
A living world holds subjects several times its cell budget on purpose. The 2,400-subject, 240-cell profile is the design target: enough goal-bearing actors at every level that the world has its own ends, and few enough cells that attention is scarce and the scheduler must choose. Scarcity is the choke that produces selection, offscreen consequence, and the feeling that things happen whether or not anyone is watching. Four mechanisms carry that, none of which is a second identity layer:
- Budgeted connected cover. Every active subject is in the cover every
tick. The scheduler partitions the agency graph — containment, membership,
jurisdiction, shared place, relation, pressure — into at most the cell
budget, giving singleton cells to the highest-pressure and highest-debt
subjects and grouping the rest by adjacency. The cover is derived and
disposable; the kernel never sees it. Populations and institutions are
subjects in their own right, and
IndividuationRequiredstill fires when a pressure needs a person no slice can bear. - Zero-inference motion.
Time.advanceapplies every due clock deterministically: aRoutinecommitment whose preconditions hold auto-fulfills, so ordinary life proceeds for unattended subjects; anObligationorGoalpast due advancesPressureon its subject. The quiet world moves without being looked at and without inventing spurious crisis. - Ordered attention. The scheduler is a pure planner over one revision. It orders opportunities by unresolved pressure, then time since last opportunity, then subject id, so every subject receives direct attention within bounded ticks absent a mandatory foreground override.
- Cell resolution. A singleton cell is detail focus: a
NarrativePersonacontroller receives its prose membrane, anOperationalAgentits full permissioned view. A grouped cell is one inference over its constituents' partitioned views — each constituent's private knowledge stays labeled as its own, never unioned — returning zero or one attributed proposal per constituent, each verified separately by the action pipeline. ANarrativePersonasubject in a grouped cell is represented operationally at coarse resolution this tick; its controller, scope, and authority do not change. The cell can emit no cell-owned mutation, and no subject is ever spoken for by an arena.
Debt rotation makes the choke fair. With N active subjects, a cell budget B,
and U urgency slots reserved for the head of the attention order, the
rotation reserve is R = B − U, and a subject continuously active for
ceil(N/R) ticks with stable membership is a singleton at least once. ceil(N/B)
is unreachable whenever N > B, because it would leave subjects uncovered. The
constituent cap yields for two reasons, when the budget's token capacity is
short of the active count and when connected components cannot pack inside
the cell budget even with capacity to spare; the cell budget never yields;
oversubscribed is the operator-visible signal that the cap gave way. The
cover is pure over its inputs and the attention order is a real input: the
same subjects in a different order give the same coverage and a different
singleton set, because urgency and backfill read that order. The deterministic clocks keep commitments moving in
between.
A grouped cell buys one inference, never one admission rule. Its constituents
are grouped because they are connected, so they are the subjects most likely
to contend: each attributed proposal binds to its own scope digest, and when
the first act lands (a telling changes a co-located listener's knowledge),
the second is refused ScopeChanged rather than committed on a stale scope.
Declines are submitted first so silent constituents consume their turn
without contention, and the driver reports submitted against committed per
cell so the gap is visible. The cover did not create the contention; two
singleton cells for the same pair would contend identically, and a refused
constituent costs one admission check rather than one inference. The grouping
heuristic stays. A grouped constituent has no Persona turn and no
Interpreter, so its refused proposal stays refused. A narrative subject in a
singleton cell is interrupted rather than silently refused: the lane
re-lowers once through the Interpreter with the delta the subject could
perceive since its turn, bound to the fresh digest, at the cost of one
Interpreter inference and no Persona re-run. Three rules govern it: the
kernel's own scope digest is the one detector of a moved scope for the
narrative lane, because the lane's own early checks are gone and only the
operational lane keeps its early check; an author is named only for speech
the subject actually heard (Overheard), and every other change that moved
the digest — a transfer, a route closing, a revocation, a vacated office, a
routine's due rolling, an elaborator patch, a consumer document — is
anonymous by construction; and a turn is lowered at most twice, because a
re-lowered binding carries the one it replaced (interrupted_from) and no
progression arm gives that one a successor.
What stays open
The ontology does not bound the stories a world can hold, for three reasons that are structural rather than promissory:
- Affordances are data. A world declares its own action vocabulary over the closed operation set. Genre lives in the catalog, not in the kernel.
- Persona prose is free. A
NarrativePersonamay say, attempt, or feel anything; the Interpreter lowers what the vocabulary can carry (spoken words byspeak, visible acts bydisplay, each cited one verbatim span at a time and joined in prose order into one utterance and one display, so narration splitting a sentence costs nothing) and records exact gaps for the rest, which is where what the person hoped, meant, or felt stays. Unrepresentable meaning is preserved as evidence, never rejected or invented. - Structure is sparse; liveness is authored. A world activates with enough
components for its current horizon, and grows toward the scale it was given.
Ordinary life is a recurring
Commitment; a rite is aChannelwith a reach set; a private joke isPersonaMaterial. None of that waits on a count, and no count admits any of it.
The ontology does bound one thing on purpose: a consequence exists only if a component changed. Speech cannot imply an uncommitted effect. That is what makes deterministic verification possible, and it is a constraint on lying, not on storytelling.
Cut line
Deleted before replacement behavior is added, with no compatibility path:
- caller-supplied string identifiers and
SubjectRef { kind, id: String }; AdmitEntitytwo-phase admission andinitial_components;- the flat
Vec<PermittedWorldMutation>batch and every reconciliation step; - the wave-level strategic outcome resolver and the
strategic_activity_outcomeflat-JSON proposal boundary; - eight legacy component kinds that carried no decision constraint:
Capability(subsumed by affordance grants),Condition(subsumed byPressure),Posture(derivable),Memory(Persona material),CivicSystemmanifest (the typed subgraph),PopulationLineage(individuation),LifecycleandWorldTime(kernel-owned); - the titled semantic verifier and titled quotas (the eight titles return as
the stock lens set; see "Elaboration lenses and detail rules"), elaboration demand and deficit,
complexity rounds,
strategic waves, fission completion counts,
detail_debtrotation, and every*Qualificationand*Verificationtype; CampaignRegistry,WorldSeed, andpublish_session_zeroas a distinct admission path;- the rule that a stale proposal is discarded on any revision change; it is replaced by scope-digest binding.
Subtraction budget
- 20 component kinds → 12; 18
WorldMutationvariants → the pinned catalog count (29 at1244595) under 1 patch primitive, replacing both the mutation enum and the separate outcome-effect sum; - 5 qualification and verification types plus 1 outcome resolver → 0;
- titled quotas and the titled verifier, semantic qualification, and round budgets → 4 derived boundaries, 1 seed request, and 1 structurally counted scale deficit;
- 2 seed admission paths → 1;
- N model-facing tool schemas hand-written per stage → 1 derived catalog.
The only additions are the patch reducer, precondition and effect-slot checking, band selection, boundary derivation, the component types, and the tool projection. A net-additive pass beyond those has bought something the invariants did not ask for.
Build budget
No new crate, binary, dependency, or service. Types and reduction inside
crates/ghostlight/src/, one new patch module, one new affordance module,
focused ghostlight tests. No workspace-wide or
release build is admitted for this stage.
Verification contract
Beyond the existing kernel proofs, focused tests must prove:
Structure
- A patch declaring an institution whose jurisdiction references an undeclared, non-canonical place is rejected, allocates no ID, and commits nothing — the exact Run 115 shape.
- The same patch with the place declared commits both atomically.
- A draft handle resolved to the wrong kind is rejected; a cross-kind canonical reference does not compile.
- Custody that does not conserve is rejected;
admitwithout evidence is rejected. - Knowledge citing an inaccessible fact is rejected; scoped knowledge does not leak into another subject's projection.
- A rejection returns every failed check, and repairing exactly those checks yields a commit.
Action
- Acting at a distance, spending unheld custody, commanding outside authority, referencing an unknown fact, and speaking beyond channel reach are each rejected with the exact failed precondition.
- A proposal exceeding an effect slot is rejected; one inside it commits.
- The same proposal at the same revision selects the same outcome band; a different command ID may select a different one; no caller-supplied value influences the draw.
- Only the selected band's effects appear in the commit.
- A proposal whose scope digest changed is rejected; one whose scope digest is unchanged commits at a later revision.
Flow
- A defaulted commitment advances pressure on its subject; the subject then derives an opportunity; a place, resource, fact, or channel never does.
- A population slice under pressure with no person to bear it derives
IndividuationRequired, and answering it clears exactly that boundary.
Elaboration
- An
AdmitPatchanswering no boundary inactive, or a boundary the kernel does not derive, is rejected. - Two patches answering disjoint boundaries at different revisions both commit; two touching the same components conflict on scope digest.
- The generated elaborator tool catalog contains exactly the operation set and declaration kinds in this document and nothing else: every variant has one tool, every emitted branch decodes, and the counts match the exemplar lists.
- Seed admission and boundary elaboration reach the same reducer and CAS.
- A structurally sparse world — few subjects, complete references — activates and runs; no count or ratio blocks it.
Time.advanceauto-fulfills a dueRoutinewhose preconditions hold and advances pressure for a dueObligation, with no inference and no spurious pressure on unattended subjects.- A batched inference returning proposals for several controllers commits only those that pass their own precondition and effect checks; a proposal attributed to a controller outside the batch is rejected.
- With N qualified subjects and cell budget B, the derived cover contains every active subject, at most B cells, and the highest-pressure and highest-debt subjects as singletons; every subject reaches a singleton within bounded ticks.
- A subject counts toward the scale deficit only when active with one
controller, one
Goal, and one executable affordance; a rejected patch leaves the deficit unchanged and visible.