Compact persisted project state

This commit is contained in:
Meta Vens 2026-05-02 11:25:10 +01:00
commit d2e424d93e
6 changed files with 377 additions and 1234 deletions

View file

@ -12,355 +12,78 @@ Do not continue implementation automatically from a rehydrate-only request.
4. Run `npm run state:status`.
5. Restate the persisted next action before touching code or docs.
## Current Shape
## Mission
Ghostlight now has the persistence spine plus the first architecture payload:
Ghostlight exists to build socially persistent generative agents for Aetheria:
characters and institutions whose actions emerge from personality, culture,
memory, perception, incentives, material constraints, and scene pressure.
- canonical map
- scratch
- evidence ledger
- branch ledger
- compact re-entry note
- system map
- implementation plan
- Python helpers for state summary and compaction audits
- architecture notes for:
- personality structure
- signal classification
- state distributions and prompt projection
- Aetheria content generation targets
- population scaling for socially dense authored slices
- first schema seam:
- `schemas/agent-state.schema.json`
- `schemas/agent-state.required-fields.json`
- `examples/agent-state.call-of-the-void.json`
- `tools/validate_agent_state.py`
- prompt projection and distillation docs:
- `docs/architecture/prompt-projection-contract.md`
- `docs/architecture/projection-distillation-plan.md`
- `docs/architecture/sequential-agent-runtime.md`
- `docs/architecture/ink-branching-scenes.md`
- evaluation follow-up docs:
- `docs/architecture/schema-future-mechanisms.md`
- Aetheria lore grounding docs:
- `docs/architecture/aetheria-lore-grounding-architecture.md`
- `docs/architecture/lore-grounding-digest-format.md`
- `docs/architecture/projected-local-context.md`
- `docs/architecture/soft-model-training-artifacts.md`
- `docs/architecture/training-plan.md`
- `docs/architecture/technology-item-manifest-plan.md`
- lore grounding seam:
- `schemas/lore-grounding-digest.schema.json`
- `examples/lore-grounding/historical-flashpoint.template.json`
- `examples/lore-grounding/cold-wake-panic.ganymede-corridor.json`
- `tools/validate_lore_grounding.py`
- coordinator artifact seam:
- `schemas/coordinator-artifact.schema.json`
- `examples/coordinator/cold-wake-sanctuary-intake.v0.json`
- `tools/validate_coordinator_artifacts.py`
- `npm run coordinator:validate`
- sandboxed responder packet seam:
- `docs/architecture/sandboxed-responder-packets.md`
- `schemas/responder-packet.schema.json`
- `schemas/responder-output.schema.json`
- `examples/responder-packets/scene-02-sanctuary-intake.sella_ren.packet.v0.json`
- `examples/responder-packets/scene-02-sanctuary-intake.sella_ren.packet.v1.json`
- `examples/responder-packets/scene-02-sanctuary-intake.sella_ren.packet.research.v0.json`
- `experiments/responder-packets/cold-wake-sanctuary-intake-sella-v0.capture.json`
- `experiments/responder-packets/cold-wake-sanctuary-intake-sella-v0.mutation.json`
- `experiments/responder-packets/cold-wake-sanctuary-intake-sella-retrieval-v0.capture.json`
- `experiments/responder-packets/cold-wake-sanctuary-intake-sella-lane-comparison.v0.json`
- `tools/build_responder_packet.py`
- `tools/validate_responder_packets.py`
- `tools/validate_responder_outputs.py`
- `tools/apply_responder_output_mutation.py`
- `npm run responder-packets:validate`
- `npm run responder-outputs:validate`
- Cold Wake story-lab seam:
- `docs/experiments/cold-wake-story-lab.md`
- `examples/agent-state.cold-wake-story-lab.json`
- `examples/projections/cold-wake-story-lab.jsonl`
- `experiments/cold-wake-story-lab/the-narrowest-possible-margin.md`
- archived local-model prototype captures under `experiments/cold-wake-story-lab/`
- `tools/build_cold_wake_story_lab_fixture.py`
- Ink branching and mutation seam:
- `examples/ink/cold-wake-sanctuary-intake.ink`
- `examples/ink/cold-wake-sanctuary-intake.training.json`
- archived prototype Ink/capture receipts under `examples/ink/` and `experiments/ink/`
- `tools/validate_ink_examples.py`
- `tools/materialize_sequential_capture.py`
- `tools/apply_sequential_ink_branch_mutation.py`
- `inkjs` dev dependency and `npm run ink:validate`
- projected local context seam:
- `schemas/projected-local-context.schema.json`
- `examples/projected-contexts/scene-02-sanctuary-intake.maer_tidecall.projected-context.json`
- `examples/projected-contexts/scene-02-sanctuary-intake.sella_ren.projected-context.json`
- `tools/project_local_context.py`
- `tools/validate_projected_contexts.py`
- includes an embodiment/interface section so Navigator action is projected
from checked Aetheria lore instead of default human body assumptions;
- now includes `runtime_retrieval_requirements` and
`latent_pressure_requirements` so compact lore facts and character-local
scars survive projection without becoming mandatory confession prose;
current source supports fluid architecture, acoustic signaling, communal
orientation chambers, mixed-species translation/coexistence, and specialized
cetacean environments; AetheriaLore has now been patched with mixed
wet/dry habitat and interface ergonomics
- Cold Wake fixture note:
- `docs/architecture/aetheria-cold-wake-training-fixture.md`
- first projection example seam:
- `schemas/projection-example.schema.json`
- `examples/projections/call-of-the-void.scene-broken-taxi-oz.jsonl`
- `examples/projections/call-of-the-void.scene-broken-taxi-oz.pretty.json`
- `tools/validate_projection_examples.py`
- visitor-facing README refreshed to explain Ghostlight's goals
The live product-facing goal is procedural branching scene generation for games:
speech and non-speech actions, NPC responses, consequences, future hooks, and
state/memory/social-perception mutation. The wider ambition includes narrated
story scaffolding, Elysium branch exploration, psychologically grounded consumer
behavior, major faction decision-making, and technology/item manifest generation.
There is still no full runtime yet. The live machine is design, state
discipline, a cleaner repo boundary, the first executable state contract, a
documented projection path, the first Ink-backed playable branching scene, the
first prototype-generated Ink draft with reviewed training annotations, and the
first reviewed mutation receipt showing how a selected generated branch changes
both involved characters. The soft-model training doctrine is now explicit:
deterministic gates stay code, while fuzzy judgments become reviewed artifacts
for future coordinator/story-runtime, projector, character-agent, appraiser,
mutator, relationship/perception, Aetheria responder, and
institution/faction/consumer decision models.
The coordinator is currently the authoring agent: it glues scenes together,
maintains continuity, chooses which machinery runs, emits connective prose, and
proposes world-state changes. Keep those outputs structured enough for future
game-engine integration instead of letting them rot as chat-only intuition.
Gold responder data must be sandboxed. The coordinator may be omniscient, but a
responder example is only valid if the acting worker saw exactly the projected
local packet, visible event, allowed action space, and explicitly included source
excerpts. Do not let responder workers inherit full chat/coordinator context when
generating training data. Preserve exact responder-visible input, raw output,
reviewed output, hidden-context refs, leakage audit, isolation method, and
coordinator intervention labels. Coordinator repairs are allowed, but they must
be labeled as repairs rather than treated as raw responder behavior.
The concrete training plan now enumerates the trainable stages, their inputs,
outputs, likely model families, artifact families, and pilot corpus gates. The
listed pilot counts are schema shakedown thresholds, not robust training
targets. They exist to expose missing fields, bad boundaries, leakage risks, and
validator gaps before large data generation. Robust organs will need roughly an
order of magnitude more examples, with separate review-assistant and runtime
targets.
The first coordinator artifact seam now exists. It captures scene setup,
next-beat choice, acting-agent choice, machinery invocation plan, sandboxed
responder handoffs, world-state refs, proposed deltas, branch constraints,
item-manifest deltas, unresolved hooks, glue prose, and review status. The first
example is a backfilled Cold Wake sanctuary packet-assessment artifact accepted
as draft for schema shakedown, not gold responder data.
The first responder packet seam now exists. It converts a coordinator artifact
and projected local context into the exact packet-only prompt surface a
character responder may see, with visible event, allowed actions, source
excerpts, hidden-context audit, isolation requirements, output contract, and
validator checks against raw-state or coordinator-context leakage. The first
Sella packet is accepted as draft for sandbox testing, not as gold responder
output. The first no-fork responder output capture now also exists and is
accepted as draft: the worker received only the packet prompt, returned valid
JSON, preserved Sella's read as interpretation, left packet personhood
unresolved, and required no coordinator prose repair.
Responder data now has two explicit lanes. `packet_only` is the runtime-parity
lane: curated source excerpts are in the packet and the responder does not
search lore. `retrieval_augmented` is the lore-absorption lane: the coordinator
or a retrieval worker searches a declared AetheriaLore scope, then gives the
responder a bounded packet. Do not use retrieval-augmented examples as proof
that the packet-only runtime prompt has enough context, and do not describe
them as autonomous responder research unless the responder actually had repo
access.
There is now an explicit research-enabled mode:
`responder_scoped_repository_search`. Use it only when the responder is allowed
to inspect the declared lore scope. The packet must include `Required Lore
Research`, `allowed_scope`, and `research_instructions`; the output capture must
include consulted refs and a research summary. A research-enabled responder that
answers without consulting lore has failed the assignment, bless its little
unexamined heart.
The first concrete research-enabled Sella packet now exists at
`examples/responder-packets/scene-02-sanctuary-intake.sella_ren.packet.research.v0.json`.
It is generated with
`tools/build_responder_packet.py --lore-access-mode responder_scoped_repository_search`,
sets `no_repo_access` false, and requires `consulted_refs` plus
`research_summary` in the responder object.
The v1 Sella packet removes responder-visible references to absent coordinator
knowledge and adds curated AetheriaLore excerpts for Cold Wake, the Ganymede
Route Compact, Navigator rescue ledgers, and Lightsail reliability.
The packet builder now gets those source excerpts from projected
`runtime_retrieval_requirements` rather than from a static hand-written list.
For the current Sella packet, that pulls Cold Wake heat-debt, Navigator rescue
ledger, Aya sanctuary-capacity, and Ganymede/Lightsail route-obligation facts
into packet-only context.
The packet-only Sella capture has now been materialized into a reviewed mutation
receipt and mutated fixture:
`examples/agent-state.cold-wake-story-lab.after-sella-conditions.json`. The
mutation accepts a conditional cold repair-bay path as scene-local state, keeps
packet personhood unresolved, and updates Maer and Sella state, relationship
stance, memories, and perceived overlays.
The first retrieval-augmented Sella capture also exists. It uses
coordinator-selected scoped AetheriaLore refs and produces richer
Aetheria-native language around heat-debt timing, rescue ledgers, dockfall
burden, and sanctuary as moral-debt sink. The lane comparison records that this
is good lore-absorption data but not proof of packet-only runtime sufficiency.
Follow-up review clarified the real concern: Sella's packet-visible
sanctuary-collapse scar does not need to surface in speech, but it must remain
visible to the responder as latent behavioral pressure. Future
projector/retrieval review should verify pressure availability, not reward
mission-critical trauma-dumping.
It now uses three timeline lanes: `historical_grounded`,
`transition_grounded`, and `future_branch`. Future branches are required
training/evaluation material for post-Rupture Elysium concepts, but generated
branch assumptions are branch-local canon indexed by lineage, not global facts
shared by every Elysium history.
## Current Focus
## Current Direction
The active path is not the archived local-model prototype runner. The active
path is:
Use Ghostlight first for:
1. Source-ground Aetheria context.
2. Project canonical state into character-local operating context.
3. Build an exact responder packet.
4. Run a sandboxed responder with only the allowed packet/context/research scope.
5. Capture raw output, consulted refs, research summary, reviewed output,
leakage audit, and coordinator interventions.
6. Apply only reviewed mutations into state, memory, relationships, perceived
overlays, and unresolved hooks.
- content generation inside the Call of the Void slice described in
`AetheriaLore`
- dialogue scaffolding and procedural drama for narrated Aetheria timeline
stories
## Live Seams
Cold Wake is now selected as the first historical grounding fixture because it
is authored pre-Elysium lore. It is not the current game target. Treat it as
training feedstock for projection and dialogue scaffolding.
- Canonical map: `state/map.yaml`
- Current system map: `notes/ghostlight-current-system-map.md`
- Implementation plan: `notes/ghostlight-implementation-plan.md`
- Agent-state schema: `schemas/agent-state.schema.json`
- Projected local context schema: `schemas/projected-local-context.schema.json`
- Coordinator artifact schema: `schemas/coordinator-artifact.schema.json`
- Responder packet schema: `schemas/responder-packet.schema.json`
- Responder output schema: `schemas/responder-output.schema.json`
- Research-enabled Sella packet: `examples/responder-packets/scene-02-sanctuary-intake.sella_ren.packet.research.v0.json`
- Packet builder: `tools/build_responder_packet.py`
- Packet/output validators: `tools/validate_responder_packets.py`, `tools/validate_responder_outputs.py`
## Aetheria Grounding Doctrine
Archived prototype captures and tools remain as evidence under `experiments/`,
`examples/ink/`, and old `run_qwen_*` helpers. They are useful receipts, not the
current gold-data route.
Before writing or generating Aetheria scenes, check AetheriaLore for the
factions, movements, institutions, species or body types, location, and time
period involved. If a blocking detail is missing, patch the lore source with a
narrow elaboration before treating the detail as available to Ghostlight.
## Aetheria Doctrine
- Cold Wake is a historical pre-Elysium grounding fixture, not the product target.
- Call of the Void remains a consumer target for content generation and dialogue scaffolding.
- Elysium futures are branch-local canon indexed by lineage.
- Before generating Aetheria scenes, check lore for factions, movements,
institutions, species/body affordances, location, time period, infrastructure,
and material constraints.
- If a blocking lore gap appears, patch AetheriaLore narrowly before treating the
detail as available to Ghostlight.
- Technology exploration should emit database-shaped item/assembly/component/
supply-chain candidates mapped toward Aetheria-Economy's CultCache item model.
## Current Next Action
Run a sandboxed no-fork research-enabled responder against
`examples/responder-packets/scene-02-sanctuary-intake.sella_ren.packet.research.v0.json`,
allowing only the declared AetheriaLore scope. Capture exact visible input,
consulted refs, research summary, raw output, review labels, and leakage audit.
Review whether the output uses institutional lore and latent pressure without
prompt parroting, omniscience, or mission-critical trauma-dumping. Do not use
archived local-model prototype runners for gold responder data.
Cat/Oz remains useful as an Elysium procedural mechanics fixture, but
single-history grounding should start from authored historical lore rather than
gameplay-era Elysium outcomes.
Post-Rupture future branches should be generated too, under explicit branch
labels, so the models learn Aetheria concepts that only exist after the
Rupture: Aether, pseudospace, temporal nonlinearity, spirits, necrotech,
mutable bodies, altered substrates, and the fresh little institutional crimes
that grow around them.
Future branches now also need event constraint labels:
`branch_attractor`, `fated_event`, `tech_order_constraint`, `quest_injection`,
or `branch_local_event`. This supports likely Elysium faction births, authored
rails, baked-in technology order, and quest injection into active timelines.
Future and historical exploration should also emit technology/item manifest
data: item families, variants, assemblies, subassemblies, components, materials,
faction tech-base access, prerequisites, bottlenecks, compatibility rules,
upgrade surfaces, economic consequences, and quest hooks. Pre-Elysium starting
tech is part of this because factions enter Elysium with asymmetric industrial
bases and supply chains.
Existing named but nebulous technologies should be elaborated into blueprint
candidates during the same process. Separate source facts, inferred
engineering, and open lore gaps so item database candidates do not pretend the
timeline already answered every manufacturing question.
The concrete schema target already exists in Aetheria-Economy: CultCache-backed
`ItemData` subclasses are technological blueprint records. `SimpleCommodityData`
defines fungible resources, `CompoundCommodityData` defines assemblies,
subassemblies, components, processed materials, and crafted economic units,
`ConsumableItemData` defines usable consumables, and `GearData` plus other
`EquippableItemData` subclasses define top-level usable gear. Runtime
`ItemInstance` objects carry realized quality, provenance, manufacturer
branding, assembly history, and world-state placement. Ghostlight should attach
recipes, assembly trees, compatibility, tooling, facilities, process
requirements, and supply-chain dependencies to the relevant blueprint as
manifest metadata or engine-schema gaps until Aetheria-Economy exposes explicit
storage for those details.
The player-facing fantasy is provenance hunting. An ultimate laser is not only a
high-stat blueprint; it is a realized artifact assembled from rare or excellent
subsystems, manufacturer processes, repair history, counterfeit substitutions,
salvage scars, ownership chains, and operating conditions. Players should be
able to follow those threads through trade, salvage, espionage, faction access,
obsolete factories, and miserable little wars over parts like a beam-control
wafer some dead manufacturer only made for nine months before regulators ate the
board.
Ghostlight's job is to make that content scalable without turning it into
sludge. Treat the technology pipeline as a content refinery: ground the concept
in lore, decompose it into parts and supply chains, map it to the economy
blueprint classes, define performance and instance variation, preserve review
labels and source gaps, then emit database-shaped candidates instead of another
spreadsheet swamp.
The evaluation follow-up fixed the immediate v0 schema issues:
- `behavioral_dimensions.warmth` became `interpersonal_warmth`
- `voice_style.warmth` became `verbal_warmth`
- Cat now has a perceived-state overlay for Oz
- Cat and Oz now have relationship summary memories
- `event-drone-lie` now includes observed exchange, private interpretations,
and event effects
Completed projection path items:
- defined projection examples, Cold Wake grounding, story-lab fixtures, and projection controls
- adopted Ink as the playable branching scene format
- built and validated local-awareness, projected-context, responder-packet, capture, and mutation seams
- preserved archived local-model prototype captures as reviewed receipts, not active guidance
- materialized one accepted projector-routed prototype branch into Ink, sidecar annotation, mutation receipt, and mutated fixture
- extracted the important lessons: character-local context, source-checked embodiment, object custody, per-turn consolidation, structured failure receipts, and no raw-state leakage into responder prompts
Remaining projection path:
- build a deterministic speaker-local input slicer
- build a renderer that emits projection controls before prompt prose
- review the embodiment-aware materialized v10 Ink and mutation receipt for
narrative quality and state-change plausibility
- keep using sandboxed responder packets and reviewed outputs for fresh
generation passes
- source-checked retries improved Maer's grounded embodiment, but no capture was
materialized because Sella appraisal/response still exposed object-custody
drift, invented mutation paths, structured-output dropout, or
prompt-constraint leakage
- next pass should focus on separating response constraints from in-world prose
before chasing another materialized Ink branch
- decide whether to polish this Ink text by hand or generalize the sequential
materializer for future accepted captures
- preserve the no-thinking default for strict tool-call generation unless a
diagnostic run explicitly needs `--think`
- improve the local-awareness-to-Ink prompt so semantic `training_hooks` do not
drift into future branch ids, object custody remains branch-local, and action
labels come from the exact canonical enum
- materialize a validated sequential branch into Ink
- keep the near-term product target to interactive dialogue trees and
scene-local consequences
- preserve training-data hooks for future open-world behavior, iterated
decisions, psychologically grounded consumer choices, scarcity/reputation
pressure, and major faction or institution decision-making
- defer implementing world-scale simulation loops, autonomous offscreen
factions, economy loops, and long-horizon plot machinery until the scene-local
machine works
- use a frontier teacher model to generate/audit projection artifacts
- train a smaller student projector only after the artifact schema, input
slicer, and evaluator stabilize
- treat the character agent/responder as a training target too: an
Aetheria-tuned local model can eventually learn lore, tone, factional
preconceptions, species affordances, and institutional pressure from a corpus
of strong responses spread throughout the timeline plus reviewed Ghostlight
receipts, while still acting only inside character-local context and
deterministic mutation gates
- require responder sandboxing before gold data generation: exact
responder-visible input, raw output, reviewed output, hidden-context refs,
leakage audit, isolation method, and coordinator repair labels must be saved
consulted refs, research summary, raw output, review labels, leakage audit, and
any coordinator intervention. Review whether the output uses institutional lore
and latent pressure without prompt parroting, omniscience, or mission-critical
trauma-dumping. Do not use archived local-model prototype runners for gold
responder data.
## Warnings
- Do not let this repo become a mirror maze of notes that say the same thing
in slightly different outfits.
- Keep canonical state small. If evidence starts turning into an activity feed,
cut it back.
- Keep the prompt-projection doctrine intact: prompt text is projection, not
truth storage.
- Do not accidentally re-promote the older corridor-crisis idea into a game MVP
because an old doc had a strong chin and good lighting.
- `notes/evaluation.md` may exist as an untracked user-supplied file for the
next session. It was intentionally left unread and uncommitted during the
compaction prep.
- Keep persistent state small. Git history and artifacts own chronology.
- Do not let notes, map, handoff, and evidence become four versions of the same brain.
- Do not train on coordinator-repaired responder prose unless the repair is labeled.
- Do not let Elysium branch futures overwrite Sol single-history facts.
- Do not rebuild the older corridor-crisis game slice by accident.

View file

@ -1,284 +1,83 @@
# Ghostlight Current System Map
Ghostlight does not have a runtime yet. The live system right now is the repo's
state and re-entry discipline.
Ghostlight still does not have a full runtime. The live system is a set of
validated artifact seams for producing reviewed training data.
## Current Control Flow
## Control Flow
1. A user or agent enters the repo with a bounded question or implementation
goal.
2. The session rehydrates from:
- `state/map.yaml`
- `notes/fresh-workspace-handoff.md`
- this file
- `notes/ghostlight-implementation-plan.md`
3. The session runs `npm run state:status` to recover the current summary, next
action, and active subgoals.
4. Work happens in one bounded slice.
5. If understanding changes, the map is updated.
6. If future belief changes, distilled evidence is appended.
7. If compaction pressure rises, the helper audits state hygiene before the
session banks the fire.
1. Rehydrate from `state/map.yaml`, `notes/fresh-workspace-handoff.md`, this
file, and `notes/ghostlight-implementation-plan.md`.
2. Run `npm run state:status`.
3. Work one bounded organ.
4. Validate the seam that matters.
5. Persist only belief-changing evidence.
6. Commit and push completed work.
## Live Surfaces
## Core Surfaces
- `state/map.yaml`
- canonical experiment, objective, constraints, invariants, active subgoals,
accepted design, and current status
- `state/scratch.md`
- temporary working memory for one bounded organ
- `state/evidence.jsonl`
- durable belief-changing records only
- `state/branches.json`
- explicit hypothesis or branch tracking
- `notes/fresh-workspace-handoff.md`
- re-entry packet
- `notes/ghostlight-implementation-plan.md`
- larger-organ sequence
- `docs/research/`
- research backlog and social-model notes
- `docs/architecture/`
- world, state, and prompt-system architecture notes
- `docs/architecture/prompt-projection-contract.md`
- contract for turning durable state into speaker-local pressure prose and
prompt sections
- `docs/architecture/projection-distillation-plan.md`
- plan for using a frontier teacher model to generate reviewed projection
artifacts before training a smaller student projector
- `docs/architecture/sequential-agent-runtime.md`
- scene-local dialogue/runtime loop where agents act from local awareness,
generated actions become event proposals, and bounded state mutation drives
branchable speech or non-speech scene consequences while preserving
training hooks for later open-world, economic, and faction decision models
- `docs/architecture/ink-branching-scenes.md`
- integration contract that makes Ink the standard playable branch format
while Ghostlight owns local awareness, projection rationale, consequence
review, and state mutation around Ink scenes
- `docs/experiments/cold-wake-story-lab.md`
- four-scene Cold Wake writing experiment using Ghostlight projection as a
story-generation crutch and training-data source
- `docs/architecture/schema-future-mechanisms.md`
- parking lot for appraisal, transition, belief, action, conversation,
resource, dyad, institution, memory, and embodiment mechanisms not yet
promoted into the v0 schema
- `docs/architecture/aetheria-lore-grounding-architecture.md`
- boundary and plan for grounding single-history training data in authored
Aetheria history while treating Elysium gameplay-era outcomes as
conditional branch canon;
includes the source-first doctrine for checking AetheriaLore and patching
blocking lore gaps before generation, plus a `future_branch` lane for
reviewed possible post-Rupture Elysium futures
- `docs/architecture/lore-grounding-digest-format.md`
- human-facing format guide for cultural, factional, institutional, role, and
speaker-boundary lore digests
- `docs/architecture/projected-local-context.md`
- contract for the projector seam that turns canonical state into
character-local operating context before a response model sees it,
including source-checked embodiment and interface affordances, runtime
retrieval requirements, and latent pressure handling
- `docs/architecture/soft-model-training-artifacts.md`
- doctrine for treating every non-deterministic judgment as reviewed
training material for future specialized models, including
coordinator/story runtime, projector, character agent/responder, appraiser,
state mutator, relationship/perception classifier, Aetheria responder, and
institution/faction/consumer decision models
- `docs/architecture/sandboxed-responder-packets.md`
- contract for the exact packet-only surface handed from an omniscient
coordinator to a sandboxed character responder, including visible event,
local prompt, allowed actions, source excerpts, hidden-context audit, and
output contract; also defines the separate `packet_only` and
`retrieval_augmented` responder-data lanes
- `docs/architecture/training-plan.md`
- concrete enumeration of trainable Ghostlight stages, including each stage's
inputs, outputs, likely model architecture, artifact family, first training
gate, and timeline coverage across historical grounded, transition
grounded, and future-branch examples
- `docs/architecture/technology-item-manifest-plan.md`
- plan for turning coordinator-led Aetheria exploration into game-usable
item, component, assembly, faction tech-base, prerequisite, supply-chain,
and upgrade-path data, including elaboration of existing nebulous named
technologies into blueprint candidates; now explicitly targets the
Aetheria-Economy CultCache `ItemData` technological blueprint classes
instead of a parallel Ghostlight item database
- `docs/architecture/aetheria-cold-wake-training-fixture.md`
- human-facing note that reframes the recovered Cold Wake scenario as
historical projection feedstock rather than the active product target
- `schemas/agent-state.schema.json`
- v0 canonical agent-state contract for agents, relationships, events,
scenes, perceived overlays, and dialogue context packs
- `schemas/projection-example.schema.json`
- v0 reviewed projection artifact contract for speaker-local prompt
projection examples, including projection controls for frame, authority,
object custody, required semantics, and forbidden resolutions
- `schemas/lore-grounding-digest.schema.json`
- v0 contract for grounding historical fixtures in source-backed cultural and
factional pressure fields
- `schemas/projected-local-context.schema.json`
- v0 contract for projected character-local operating context artifacts,
including structured runtime retrieval requirements and latent pressure
requirements
- `schemas/coordinator-artifact.schema.json`
- v0 contract for coordinator/story-runtime receipts: scene setup,
next-beat choice, acting-agent choice, machinery invocations, sandboxed
responder handoffs, world-state refs, proposed deltas, branch constraints,
item-manifest deltas, unresolved hooks, glue prose, and review notes
- `schemas/responder-packet.schema.json`
- v0 contract for the exact input a sandboxed character responder may see,
now lane-labeled as `packet_only` or `retrieval_augmented` with explicit
lore-access policy; research-enabled packets can require
responder-scoped repository search with visible research instructions
- `schemas/responder-output.schema.json`
- v0 contract for reviewed captures from sandboxed responder workers,
preserving raw output, parsed output, isolation method, leakage audit, and
coordinator review; output captures also preserve generation lane and
consulted lore refs, and research-enabled captures can preserve a research
summary
- `schemas/agent-state.required-fields.json`
- required first-class variable names for canonical state and relationship
stance
- `examples/agent-state.call-of-the-void.json`
- first Call of the Void-flavored fixture for schema and projection work
- `examples/agent-state.cold-wake-story-lab.json`
- first story-shaped historical fixture for Cold Wake projection work
- `examples/projections/call-of-the-void.scene-broken-taxi-oz.jsonl`
- first reviewed Cat and Oz projection examples
- `examples/projections/call-of-the-void.scene-broken-taxi-oz.pretty.json`
- pretty-printed mirror for inspecting the first projection examples
- `examples/projections/cold-wake-story-lab.jsonl`
- response-turn projection examples for the Cold Wake story lab, including
rejected and accepted Maer/Veyr prompt revisions
- `examples/coordinator/cold-wake-sanctuary-intake.v0.json`
- first coordinator artifact schema-shakedown example, backfilled from the
accepted-as-draft sanctuary packet-assessment beat and explicitly marked as
not gold responder data
- `examples/responder-packets/scene-02-sanctuary-intake.sella_ren.packet.v0.json`
- first responder-packet schema-shakedown example for Sella's sanctuary
response; accepted as draft for sandbox handoff testing, not gold responder
output
- `examples/responder-packets/scene-02-sanctuary-intake.sella_ren.packet.v1.json`
- corrected packet-only Sella handoff with absent hidden context moved out of
responder-visible prose and curated AetheriaLore excerpts added for Cold
Wake, Ganymede rescue obligations, Navigator rescue ledgers, and Lightsail
reliability
- `examples/responder-packets/scene-02-sanctuary-intake.sella_ren.packet.research.v0.json`
- first concrete research-enabled Sella handoff; it uses
`responder_scoped_repository_search`, declares the allowed AetheriaLore
scope, permits repo access only for that scope, and requires consulted refs
plus research summary in the responder object
- `experiments/responder-packets/cold-wake-sanctuary-intake-sella-v0.capture.json`
- first no-fork sandboxed responder output capture from the Sella packet;
accepted as draft with no leakage flags and no coordinator prose repair
- `experiments/responder-packets/cold-wake-sanctuary-intake-sella-v0.mutation.json`
- reviewed mutation receipt that materializes the packet-only Sella response
into scene-local state, relationship, memory, perceived-overlay, and
unresolved-hook updates without resolving packet personhood
- `experiments/responder-packets/cold-wake-sanctuary-intake-sella-retrieval-v0.capture.json`
- first retrieval-augmented responder capture using coordinator-selected
scoped AetheriaLore refs
for Aya sanctuary politics, Cold Wake heat-debt pressure, Navigator rescue
ledgers, Ganymede route obligations, and Lightsail reliability
- `experiments/responder-packets/cold-wake-sanctuary-intake-sella-lane-comparison.v0.json`
- comparison artifact showing the packet-only lane proves bounded runtime
competence while the retrieval-augmented lane adds stronger
Aetheria-native institutional texture, retrieval lessons, and a warning
that character backstory must remain available as latent pressure
- `experiments/cold-wake-story-lab/`
- archived local-model response captures and reviews from the writing experiment
- `the-narrowest-possible-margin.md`, the first readable short story
assembled from accepted projection outputs
- `examples/lore-grounding/historical-flashpoint.template.json`
- fillable template for the first historical Aetheria grounding digest
- `examples/lore-grounding/cold-wake-panic.ganymede-corridor.json`
- first draft historical grounding digest, centered on Cold Wake Panic in the
Ganymede/Jovian corridor
- `examples/ink/cold-wake-sanctuary-intake.ink`
- first playable Ink-backed Cold Wake branching scene, using speech, gesture,
object revelation, and moral-pressure branches
- `examples/ink/cold-wake-sanctuary-intake.training.json`
- reviewed sidecar annotation tying Ink branches to Ghostlight local
awareness, projection controls, branch rationale, consequence surfaces, and
manual mutation policy
- archived local-model prototype Ink and capture receipts
- older files with `qwen` in the path remain in `examples/ink/` and
`experiments/ink/` as historical receipts; they are not the active
generation path and should not steer new gold-data work unless model
plumbing is explicitly being tested
- `tools/ghostlight_state.py`
- compact state inspection and evidence or branch updates
- `tools/ghostlight_prepare_compaction.py`
- pre-compaction audit of required files, handoff content, and git hygiene
- `tools/validate_agent_state.py`
- dependency-free validator for the current schema fixture invariants
- `tools/validate_projection_examples.py`
- dependency-free validator for projection example JSONL records
- archived local-model prototype tools
- older `run_qwen_*`, `materialize_qwen_*`, `validate_qwen_captures.py`, and
`check_qwen_chat_tools.py` helpers remain for validating historical
receipts and testing model plumbing; they are not the active gold-data path
- `tools/validate_lore_grounding.py`
- dependency-free validator for lore grounding digest examples
- `tools/validate_ink_examples.py`
- compiles Ink examples with `inkjs` and validates sidecar training
annotations plus reviewed prototype Ink-generation captures
- `tools/materialize_sequential_capture.py`
- turns an accepted sequential capture into playable Ink, sidecar annotation,
reviewed mutation receipt, and a mutated fixture
- `tools/project_local_context.py`
- deterministic first projector that compiles canonical state, scene facts,
relationships, memories, projection controls, and optional observed event
into character-local operating prose; for cetacean Navigators it projects
source-checked habitat affordances from AetheriaLore instead of generic
human body defaults; now emits scene-triggered compact lore retrieval
requirements and latent character-history pressure requirements
- `tools/validate_projected_contexts.py`
- validates projected context artifacts and rejects prompt text that leaks raw
canonical state internals
- `tools/validate_coordinator_artifacts.py`
- validates v0 coordinator artifacts, including sandboxed responder handoff
fields, world-state refs, branch constraints, proposed deltas, unresolved
hooks, and review status
- `tools/build_responder_packet.py`
- builds packet-only or research-enabled responder handoffs from a coordinator
artifact and projected local context; source excerpts now come from active
projected runtime retrieval requirements instead of a static lore list
- `tools/validate_responder_packets.py`
- validates responder packets and rejects prompt surfaces that leak raw state
internals or hidden coordinator context markers
- `tools/validate_responder_outputs.py`
- validates sandboxed responder output captures, including exact raw-to-parsed
JSON agreement, no-fork isolation, action labels, leakage audit, and review
metadata; also validates responder mutation receipts
- `tools/apply_responder_output_mutation.py`
- applies a reviewed responder-output capture into a mutated agent-state
fixture and mutation receipt
- `tools/apply_sequential_ink_branch_mutation.py`
- applies a reviewed replay of one selected branch into a mutated agent-state
fixture and mutation receipt without letting Ink variables become
canonical truth
- `tools/build_cold_wake_story_lab_fixture.py`
- generator for the verbose Cold Wake story-lab state fixture
- `state/map.yaml`: canonical mission, boundaries, live architecture, next action.
- `state/evidence.jsonl`: distilled belief-changing evidence only.
- `state/evidence.archive.jsonl`: older evidence preserved for archaeology.
- `notes/fresh-workspace-handoff.md`: compact re-entry packet.
- `notes/ghostlight-implementation-plan.md`: near-term implementation sequence.
- `docs/architecture/`: detailed contracts and rationale.
## What Does Not Exist Yet
## Active Artifact Pipeline
- a classifier pipeline
- a prompt renderer
- a full projection training corpus
- a deterministic projection input slicer
- a student projection model
- a simulation/event loop implementation
- a relationship engine
- a culture prior engine
- an automatic Ink branch generator from local awareness
- automatic promotion of Ink branch outcomes into canonical state
```text
Aetheria lore/source context
-> lore grounding digest / source notes
-> canonical agent and scene state
-> projected local context
-> responder packet
-> sandboxed responder output
-> review and leakage audit
-> mutation receipt
-> updated fixture / future training corpus
```
The canonical schemas and first Cold Wake fixture seams now exist as v0
contracts. Archived local-model prototype receipts proved useful for discovering
architecture lessons, but the active path is now sandboxed responder packets,
source-grounded local context, reviewed outputs, and audited mutation receipts.
Deterministic gates stay code; fuzzy coordination, projection, action choice,
appraisal, mutation, relationship movement, Aetheria responder training, and
economic/faction decision judgments become reviewed artifacts for later
fine-tuning or distillation. The next gold-data pass should use the concrete
research-enabled Sella packet and preserve exact visible input, consulted refs,
research summary, raw output, reviewed output, hidden-context refs, leakage
audit, isolation method, and coordinator intervention labels.
## Important Contracts
- Agent state: `schemas/agent-state.schema.json`
- Projection examples: `schemas/projection-example.schema.json`
- Lore grounding: `schemas/lore-grounding-digest.schema.json`
- Projected local context: `schemas/projected-local-context.schema.json`
- Coordinator artifacts: `schemas/coordinator-artifact.schema.json`
- Responder packets: `schemas/responder-packet.schema.json`
- Responder outputs: `schemas/responder-output.schema.json`
## Current Live Example
- Research-enabled packet:
`examples/responder-packets/scene-02-sanctuary-intake.sella_ren.packet.research.v0.json`
- It uses `responder_scoped_repository_search`, allows only declared
AetheriaLore scope, and requires `consulted_refs` plus `research_summary`.
- The next useful sample should be generated through a no-fork sandboxed
responder, not through archived local-model prototype runners.
## Archived Receipts
Old local-model prototype files with `qwen` in their paths remain useful for
validation and lessons about structured-output failure, object custody,
embodiment, prompt leakage, and materialization. They are not active direction.
Do not let them steer gold responder data unless the task is explicitly model
plumbing.
## Missing Organs
- Deterministic speaker-local input slicer
- Full prompt renderer
- Classifier/appraiser pipeline
- Relationship/perception updater
- State mutator model
- Student projector
- Full scene/event loop implementation
- Culture prior engine
- Automatic promotion of branch outcomes into canonical state
## Current North Star
Generate high-quality, sandboxed, source-grounded responder/coordinator samples
that can later train specialized Ghostlight models while staying usable by a
game engine: exact inputs, exact outputs, provenance, review labels, state
mutation receipts, and clear branch consequences.

View file

@ -1,398 +1,63 @@
# Ghostlight Implementation Plan
## Current Phase
Build the first reliable data-generation loop for socially persistent Aetheria
agents. The immediate target is not a full simulation. It is a clean, reviewed,
sandboxed training-data pipeline for branching scenes and state consequences.
## Near-Term Sequence
1. Freeze the first canonical state model. In progress.
- Define the latent variable families.
- Define first-class dimensions, including volatility, attachment-seeking,
and distance-seeking.
- Define canonical state versus perceived state.
- Keep authoring outputs explainable from the state, not just generated from
stylish prompt fog.
- Maintain `schemas/agent-state.schema.json`,
`schemas/agent-state.required-fields.json`, and the example fixtures as
the first executable contract.
1. Stabilize canonical state and projection seams.
- Keep `schemas/agent-state.schema.json` and required vectors coherent.
- Keep canonical state separate from perceived overlays.
- Keep voice, presentation, relationship, memory, and situational pressure explainable.
- Do not leak raw numeric state internals into responder prompt text.
2. Freeze the first event and classifier schema.
- Define event labels.
- Define canonical expression labels.
- Define listener perception labels.
- Define mask or presentation labels.
- Define confidence, uncertainty, and evidence accumulation rules.
2. Stabilize responder packet and output seams.
- Use `schemas/responder-packet.schema.json` and `schemas/responder-output.schema.json`.
- Build packets from coordinator artifacts plus projected local context.
- Preserve exact responder-visible input, hidden-context audit, allowed actions, source excerpts, output contract, and lore-access mode.
- Preserve raw output, parsed output, review labels, consulted refs, research summary, leakage audit, and coordinator interventions.
3. Build the prompt projection layer for authoring.
- Use `docs/architecture/prompt-projection-contract.md` as the first
renderer contract.
- Use `docs/architecture/schema-future-mechanisms.md` to keep appraisal,
transition, belief, action, conversation, resource, dyad, institution,
memory, and embodiment needs visible without prematurely bloating the v0
agent-state schema.
- Render scene and dialogue scaffolds from structured state, relevant
memories, scene pressure, cultural defaults, and perceived state.
- Keep the prompt renderer a projection surface instead of a second brain.
- Make generated moves inspectable: why this character deflects, confesses,
threatens, softens, bargains, or lies.
- Treat this as a debug/training seam for the larger sequential runtime, not
as the final product shape.
3. Generate the next research-enabled responder sample.
- Use `examples/responder-packets/scene-02-sanctuary-intake.sella_ren.packet.research.v0.json`.
- Run a no-fork sandboxed responder with only the packet and declared lore scope.
- Require actual lore consultation before answering.
- Review for institutional grounding, latent character pressure, non-omniscience, prompt parroting, and mission-critical trauma-dumping.
- Do not use archived local-model prototype runners for gold responder data.
4. Build the scene-local sequential dialogue loop. New target.
- Use `docs/architecture/sequential-agent-runtime.md` as the first runtime
contract.
- Use `docs/architecture/ink-branching-scenes.md` as the branch-format
contract. Ink owns playable branching scenes; Ghostlight owns local
awareness, projection rationale, consequences, and reviewed state mutation.
- Keep the product target narrow: procedural branching scene trees for games
first. "Dialogue tree" means speech and non-speech actions, not only
spoken lines.
- Do not make the training data dialogue-only. Preserve labels and state
hooks for open-world contexts, iterated decisions, consumer behavior,
scarcity, reputation, faction pressure, and institution decision-making.
- Build local awareness from scene state, agent state, relationships,
memories, resources, affordances, and known constraints.
- Consolidate participant appraisals and state mutation after every
resolved action before selecting the next actor; hurt, threat,
reassurance, obligation, overload, and misread should alter the state any
affected participant acts from.
- Keep action primitives concrete: speech, silence, movement, gesture,
object use, object transfer, object blocking, resource spending, waiting,
and attack. Treat ask/refuse/offer/reveal/conceal/request as intended
communicative functions, not separate reality-mutating tools.
- Preserve the gap between actor intent and listener interpretation; a
listener is free to misread what the actor thought they were doing.
- Treat generated action as an event proposal, not direct truth mutation.
- Resolve the event against world state and mutation authority.
- Automate only mechanical legality, visibility, world/resource/object
deltas, and event append in the first prototype.
- Keep fuzzy updates manual at first: appraisals, relationship movement,
belief changes, memory writes, intent classification, misreads, and
activation deltas. Save those reviewed decisions as future classifier and
appraiser training data.
- Keep author control at stage-setting and high-level constraints; do not
require the author to script every beat.
- Emit game-useful artifacts: Ink scene source, compiled Ink JSON, scene
transcript, candidate player choices, including non-speech actions, NPC response branches,
state/memory/social-perception deltas, and unresolved hooks.
- For protagonist scenes, generate several plausible things the protagonist
could do from state and affordances, then generate NPC responses and branch
consequences such as trust loss, suspicion, obligation, debt, resource
cost, information exposure, or future scene hooks.
- Keep out of implementation scope for now: world-scale simulation loops,
economy simulation loops, city-scale scheduling, autonomous offscreen
factions as full actors, and long-horizon plot invention without author
scaffolding.
- Still record why agents buy, refuse, trade, hoard, comply, defect, conceal,
punish, or help when those decisions appear in scenes; those reviewed
decisions are seed data for later consumer-behavior and faction models.
- First prototype: express one Cold Wake story-lab beat as Ink, compile it,
and validate a sidecar training annotation that maps branches to
Ghostlight state basis, action intent, consequence surfaces, and manual
mutation policy.
- Archived prototype drafts produced branch candidates from local awareness and proved the Ink materialization seam.
- First sequential prototype draft separated actor-local choice, participant appraisal/consolidation, and
the next actor's move from updated state. The first saved capture is
useful-needs-revision because it exposed the missing per-turn appraisal
boundary and weak action enum discipline.
- First reviewed branch mutation: use
`tools/apply_sequential_ink_branch_mutation.py` to apply one selected
generated branch into
`examples/agent-state.cold-wake-story-lab.after-sanctuary-ledger.json`
and a mutation receipt, updating both Maer and Sella without treating Ink
variables as canonical truth.
- Second sequential draft: the symmetrical turn framing produced canonical
action labels and a concrete Sella `withhold_object` next action, but
still needs stricter schema or tool-call enforcement because array fields
drifted into strings and objects.
- Archived local-model invocation lesson: model-specific chat/tool
formatting belongs in runner code and must not leak into Ghostlight
artifact formats.
- Projector gap: the sequential runner still sends selected raw numeric
state variables into prompts. This is archived scaffolding for local-model
plumbing tests, not the final Ghostlight architecture.
- Projector prototype: `tools/project_local_context.py` now turns canonical
variables, memory, relationship stance, culture, and scene pressure into
compact character-local operating context and action affordances.
- Projected-context artifacts use
`ghostlight.projected_local_context.v0` and validate through
`tools/validate_projected_contexts.py`; rendered prompt text must not leak
raw state internals such as `current_activation`, `plasticity`, means, or
decimal state values.
- Runtime retrieval/projector correction: projected contexts now carry
`runtime_retrieval_requirements` and `latent_pressure_requirements`.
Retrieval requirements render compact lore facts for scene-relevant
pressures; latent pressure requirements keep character history visible as
behavior-shaping context without forcing it into speech.
- Embodiment correction: projected local context now includes a first-class
embodiment/interface section. Aetheria faction affordances must be checked
against lore before projection. Current Navigator source supports fluid
architecture, acoustic signaling, soft navigation light, layered water
motifs, communal orientation chambers, mixed-species
translation/coexistence, specialized cetacean environments, and, after a
source patch, mixed wet/dry habitat and interface ergonomics.
- Aetheria generation doctrine: before writing scenes or generating training
data, check AetheriaLore for factions, movements, institutions, species or
body types, location, and time period. If a blocking room-scale detail is
missing, patch AetheriaLore narrowly before treating that detail as
available to projection.
- A later sequential prototype routed structured generation through
projected local context instead of selected activation dictionaries and
proved the projector boundary while preserving malformed-output failures
as receipts.
- Runner tightening: failed Maer choice generation now writes reviewed
receipts instead of exiting, obvious malformed stringified tool arrays can
be repaired, repair notes are separated from fatal validation notes, and
Sella's next-action prompt receives appraisal prose instead of raw numeric
deltas.
- Later sequential prototype drafts captured malformed structured output,
no-call dropouts, and schema-looping as reviewed failure receipts. These
are runner/model reliability lessons, not active architecture targets.
- V10 materialization: `tools/materialize_sequential_capture.py`
materialized the accepted projector-routed capture into Ink, sidecar
annotation, reviewed mutation receipt, and a mutated Cold Wake fixture.
- Next prototype work should use sandboxed responder packets and reviewed
outputs; do not revive the archived local-model runner unless explicitly
testing model plumbing.
- Source-checked retry results: v11-v17 improved Maer's body/interface
behavior substantially, producing packet actions through shared clinic
displays and mixed wet/dry affordances instead of humanoid action. No
capture was materialized because later passes exposed repair notes,
object-custody drift, invented mutation paths, one local-model appraisal
tool-call dropout, and prompt-constraint leakage into Sella prose.
- Validation correction: the sequential runner now checks Maer embodiment,
Cold Wake object semantics, Sella appraisal paths/relationship ids, and
prompt leakage in responder prose. The next implementation move should
make responder prose less likely to copy constraints verbatim before
trying to materialize another capture.
4. Materialize reviewed consequences.
- Convert accepted responder output into a mutation receipt.
- Update only reviewed scene state, memories, relationship stance, perceived overlays, and unresolved hooks.
- Keep fuzzy social changes manual and auditable until appraiser/classifier models exist.
5. Build the projection distillation loop. Started.
- Use `docs/architecture/projection-distillation-plan.md` as the teacher to
student roadmap.
- Use `docs/architecture/soft-model-training-artifacts.md` as the boundary
between deterministic code and soft model-training targets.
- Use `docs/architecture/training-plan.md` as the concrete stage inventory:
lore grounding compiler, coordinator/story runtime, memory/lore retriever,
projector, character agent/responder, event resolver, participant
appraiser, state mutator, relationship/perception updater, evaluator
classifiers, and institution/faction/consumer decision models.
- Use `docs/architecture/aetheria-lore-grounding-architecture.md` to keep
Aetheria grounded training separate from procedural Elysium branch
generation.
- Maintain `schemas/projection-example.schema.json`,
`examples/projections/`, and `tools/validate_projection_examples.py` as
the first reviewed artifact seam.
- Use authored historical Aetheria flashpoints, not malleable Elysium
gameplay outcomes, as the first grounded lore-training corpus.
- Also generate reviewed post-Rupture Elysium `future_branch` fixtures so
models learn Aetheria's weird future concepts under supervision rather
than treating late-Sol history as the whole training universe.
- Future branches must label source-backed post-Elysium concepts separately
from generated branch assumptions, branch lineage, sibling-branch
exclusions, and branch-local canonical facts.
- Future branches must also label constrained events: pressure-born
`branch_attractor`, authorial `fated_event`, discovery-gated
`tech_order_constraint`, authored `quest_injection`, or ordinary
`branch_local_event`.
- Elysium-born factions and institutions, including things like Adrasteia or
Miss Terri's Sugarrific Snack Company, should be modeled through those
labels rather than hidden in prose: they may emerge from branch pressure,
be nudged by fate, arrive through quest injection, or remain local to one
branch.
- Use `docs/architecture/technology-item-manifest-plan.md` to make future
exploration produce game-usable technology data: item families, variants,
assemblies, subassemblies, components, materials, faction access,
prerequisites, bottlenecks, compatibility rules, upgrade slots, economic
consequences, and quest hooks.
- Target the existing Aetheria-Economy CultCache item model rather than a
Ghostlight-only taxonomy. Manifest candidates should map conceptual layers
onto `SimpleCommodityData`, `CompoundCommodityData`, `ConsumableItemData`,
`GearData`, and other `EquippableItemData` technological blueprint
classes. Runtime `SimpleCommodity`, `CompoundCommodity`, `ConsumableItem`,
and `EquippableItem` instances belong to inventory/world-state simulation,
carrying realized quality, provenance, manufacturer branding, and assembly
history.
- Treat recipes, assembly trees, upgrade compatibility, tooling, facilities,
process requirements, and supply-chain dependencies as blueprint metadata
or engine-schema gaps attached to the relevant `*Data` class until
Aetheria-Economy exposes explicit storage for them.
- Use the same manifest process to elaborate existing nebulous timeline
technologies into blueprint candidates. Named tech like a
super-Planckian emitter should be decomposed into candidate assemblies,
subassemblies, components, materials, processes, tooling, facilities,
failure modes, quality tiers, and supply-chain dependencies with inferred
fields marked as inferred.
- Pre-Elysium starting tech must be manifested too. Factions do not begin
with identical tech bases, manufacturing rights, stockpiles, maintenance
skills, standards, or supply-chain dependencies.
- Maintain `schemas/lore-grounding-digest.schema.json`,
`examples/lore-grounding/`, and `tools/validate_lore_grounding.py` as the
cultural and factional pressure seam for grounded fixtures.
- Use `examples/lore-grounding/cold-wake-panic.ganymede-corridor.json` as
the first draft historical grounding digest.
- Build the first grounded projection fixture from one specific Cold Wake
room rather than from the whole crisis at once.
- Use `docs/experiments/cold-wake-story-lab.md` and
`examples/agent-state.cold-wake-story-lab.json` as the first story-shaped
writing lab.
- Treat projection outputs as response turns, not dialogue-only turns:
characters may speak, act, withdraw, stay silent, use violence, or combine
speech and action when state and scene pressure justify it.
- Keep failed and accepted prototype captures together. The Maer/Veyr v1 and v2
outputs are useful failed examples; v3 is the first accepted output that
preserves unresolved claimant status while allowing controlled physical
action.
- Treat repeated generation failures as projection architecture signals, not
only prompt wording problems. Projection examples now include controls for
frame ownership, authority boundaries, object custody, required semantics,
and forbidden resolutions.
- Keep archived local-model captures as reviewed receipts; validators keep unreviewed captures from quietly becoming training data.
- Use `experiments/cold-wake-story-lab/the-narrowest-possible-margin.md` as
the first end-to-end story artifact assembled from accepted response
captures plus authored connective narration.
- Use a frontier teacher model to produce reviewed projection artifacts from
structured state and lore grounding digests.
- Save accepted and rejected projection examples as supervised data.
- Train or adapt a smaller student projector only after the artifact schema,
input slicer, and evaluator are stable.
- Treat the character agent/responder as a training target too. A
small local model can eventually be adapted on a corpus of
strong Aetheria responses spread throughout the timeline, plus reviewed
Ghostlight receipts, so lore, tone, factional preconceptions, species
affordances, and institutional pressure become native responder priors
rather than prompt handholding.
- Generate gold responder data through a sandbox boundary. The coordinator
may know the full scene, but the responder worker should receive only the
projected local packet, visible event, allowed action space, and explicitly
included source excerpts. If the harness supports one-turn sub-agents,
start them without inherited conversation context for responder turns.
Record exact responder-visible input, raw output, reviewed output,
hidden-context refs, leakage audit, and every coordinator repair.
- Include future-branch post-Rupture responses before expecting the responder
to handle Elysium concepts such as Aether, pseudospace, temporal
nonlinearity, spirits, necrotech, mutable bodies, and altered substrates
without heavy prompt scaffolding.
- Keep deterministic gates as code even after fine-tuning: visibility,
action legality, object custody, resource accounting, schema validation,
source provenance, mutation authority, prompt leakage checks, and Ink
compilation.
- Emit reviewed artifacts for every fuzzy organ before training specialized
models: coordinator/story runtime, projector, character agent/responder,
participant appraiser, state mutator, relationship/perception classifier,
Aetheria responder, and later institution/faction/consumer decision
models.
5. Generalize the loop.
- Add more historical grounded fixtures from AetheriaLore.
- Add future-branch Elysium fixtures with branch lineage and constraint labels.
- Emit technology/item manifest deltas when scenes discover or stress gear, assemblies, supply chains, or faction tech bases.
- Keep artifacts database-shaped enough for future game-engine integration.
6. Build the coordinator artifact seam. New target.
- Treat the current authoring agent as the temporary coordinator: it glues
scenes together, decides which machinery runs, maintains continuity, emits
connective prose, and proposes world-state changes for deterministic gates
and reviewed mutation.
- Keep coordinator state game-engine-shaped even before a game engine exists:
scene ids, location ids, participants, active objects, resources, public
facts, unresolved facts, branch flags, event refs, fixture refs, and
consequences awaiting review.
- Save coordinator decisions as training artifacts: scene setup, next-beat
choice, acting-agent choice, tool/model invocation plan, glue prose,
branch merge or split decisions, world-state refs read, proposed state
changes, carried hooks, rejected prose, and reviewer notes.
- Coordinator artifacts that invoke a responder must preserve the sandbox
handoff: projected-local-context id, exact responder-visible input, hidden
context refs, isolation method, raw responder output id, reviewed output
id, and coordinator intervention labels. Do not train a responder on prose
the coordinator repaired unless the repair is explicitly labeled.
- Do not let glue prose become canonical truth. It is narrative connective
tissue and training signal; structured state and reviewed mutations decide
what happened.
- The long-term coordinator model should learn how to stage scenes, preserve
continuity, call specialist organs, and emit readable connective narration
while respecting deterministic gates and game-engine constraints.
- First concrete training-plan target: define the coordinator artifact schema
before generating another long story pass, so glue prose, next-beat choice,
world-state refs, branch flags, unresolved hooks, and machinery invocations
are captured as trainable data instead of living only in chat.
- Coordinator artifacts should be able to attach item-manifest deltas when a
scene or branch decision discovers, alters, upgrades, restricts, salvages,
counterfeits, or economically stresses a technology or item.
- First schema seam: `schemas/coordinator-artifact.schema.json`,
`examples/coordinator/cold-wake-sanctuary-intake.v0.json`, and
`tools/validate_coordinator_artifacts.py` now validate the coordinator
receipt shape through `npm run schema:validate`.
- First responder packet seam:
`schemas/responder-packet.schema.json`,
`examples/responder-packets/scene-02-sanctuary-intake.sella_ren.packet.v0.json`,
`tools/build_responder_packet.py`, and
`tools/validate_responder_packets.py` now validate the exact prompt surface
a sandboxed character responder may see.
- Responder examples now have two lanes. `packet_only` uses curated source
excerpts and tests runtime parity. `retrieval_augmented` uses coordinator
or retriever-selected scoped AetheriaLore refs, preserves consulted refs,
and is for baking lore and tone into final responder outputs rather than
proving runtime prompt sufficiency. It is not autonomous responder research
unless the artifact explicitly says the responder had repo access.
- Research-enabled responder correction: `retrieval_augmented` now has an
explicit `responder_scoped_repository_search` mode. Those packets must
surface a `Required Lore Research` section, declared `allowed_scope`, and
`research_instructions`; output captures must preserve consulted refs and
a research summary. If the responder does not consult scoped lore before
answering, the capture should fail review.
- The v1 Sella packet removes responder-visible warnings about absent hidden
context and adds curated AetheriaLore excerpts for Cold Wake, the Ganymede
Route Compact, Navigator rescue ledgers, and Lightsail reliability.
- First responder output seam:
`schemas/responder-output.schema.json`,
`experiments/responder-packets/cold-wake-sanctuary-intake-sella-v0.capture.json`,
and `tools/validate_responder_outputs.py` now preserve the raw no-fork
worker response, parsed response, isolation method, hidden-context refs,
leakage audit, and coordinator review.
- First responder mutation materialization:
`tools/apply_responder_output_mutation.py` now writes
`experiments/responder-packets/cold-wake-sanctuary-intake-sella-v0.mutation.json`
and `examples/agent-state.cold-wake-story-lab.after-sella-conditions.json`
from the packet-only Sella capture.
- First retrieval-augmented comparison:
`experiments/responder-packets/cold-wake-sanctuary-intake-sella-retrieval-v0.capture.json`
and
`experiments/responder-packets/cold-wake-sanctuary-intake-sella-lane-comparison.v0.json`
show that scoped lore access improves Aetheria-native institutional texture
around heat-debt timing, rescue ledgers, dockfall burden, and sanctuary
capacity politics, but can crowd out character-local backstory if the
projector does not protect that pressure.
- Retrieval/projector requirements are now wired into the projected-context
seam and responder packet builder. The Sella packet gets Cold Wake
heat-debt, Navigator rescue ledgers, Aya sanctuary capacity, and
Ganymede/Lightsail route obligations from projected runtime requirements
instead of a static hand-written excerpt list.
- Next prototype: use this corrected packet surface for a fresh sandboxed
responder pass, then review whether the response uses institutional lore
and latent pressure without prompt parroting or mission-critical
trauma-dumping. If the pass is research-enabled, use
`responder_scoped_repository_search` and require consulted refs before the
responder answers.
6. Train only after schemas stop sliding.
- Pilot samples are schema shakedown, not robust corpus scale.
- Specialized future models include coordinator, retriever, projector,
responder, appraiser, mutator, relationship/perception updater, evaluator,
and institution/faction/consumer decision models.
- Deterministic gates remain code: visibility, action legality, object
custody, resource accounting, schema validation, source provenance,
mutation authority, prompt leakage checks, and Ink compilation.
7. Build the first drama-scaffolding loop.
- memory updates
- relationship updates
- goal pressure
- situational activation
- cultural and institutional pressure
- conflict beats derived from incompatible goals and values
## Deferred
8. Build the first Aetheria authoring consumer.
- use the Call of the Void slice described in `AetheriaLore` as the first
concrete content-generation context
- treat Call of the Void and other Elysium gameplay-era fixtures as
procedural branch material unless specific outcomes are explicitly
promoted
- support dialogue scaffolding and procedural drama for narrated stories
across the Aetheria timeline
- do not treat Cold Wake as the implementation target unless explicitly
revived later; it is currently training feedstock
- Full world simulation loop
- Autonomous offscreen faction simulation
- Economy simulation loop
- Long-horizon plot generation without author scaffolding
- Fine-tuning before artifact schemas, review criteria, and evaluators stabilize
## Discipline
- Do not start with an MMO and call it ambition.
- Do not train a classifier before the label schema is stable enough to deserve
the trouble.
- Do not let prompt-writing outrun the structured state model.
- Do not fine-tune a projector before the projection artifact schema, input
slicer, and evaluator have stopped sliding around.
- Do not let elegant theory notes multiply faster than implementation seams.
- Do not accidentally rebuild a game slice when the requested consumer is an
authoring and story-generation organ.
- Work one bounded organ at a time.
- Prefer explicit maps and contracts over implicit context.
- If the diff grows while understanding shrinks, stop and simplify.
- Keep history in git and archived receipts; keep persisted state focused on the mission.