Define branching scene tree target

docs/architecture/sequential-agent-runtime.md

@@ -2,9 +2,15 @@
 
 Ghostlight's near-term target is not a general-purpose life simulator.
 
-The near-term product target is procedural interactive dialogue: set up a scene,
-let characters choose believable responses, expose player-facing choices, and
-propagate consequences into state, memory, and social perception.
+The near-term product target is procedural interactive dialogue in the game
+sense: branching scenes where choices can be speech, silence, movement, object
+use, refusal, revelation, concealment, violence, withdrawal, trade, or any other
+scene-valid action. "Dialogue tree" does not mean a tree made only of spoken
+lines. It means an interactive branch structure for a character encounter.
+
+Ghostlight should set up a scene, generate plausible things the protagonist or
+NPCs could do, generate responses from the people present, and propagate the
+consequences into world state, memory, belief, and social perception.
 
 The long-term target is broader. The same classifiers, appraisers, and
 projection models should eventually operate inside a simulated game world with
@@ -15,8 +21,8 @@ shortage. Also do not build the whole economy today. Both cliffs are stupid.
 
 The runtime target for now is scene-local: choose which character is acting,
 give that character local awareness, let them act, apply consequences, mutate
-the relevant state, and continue until the scene produces a usable dialogue
-tree, scene transcript, or branch scaffold.
+the relevant state, and continue until the scene produces a usable branching
+scene tree, scene transcript, or branch scaffold.
 
 Single-turn projection remains useful, but it is a microscope, not the animal.
 
@@ -40,7 +46,7 @@ withdrawal, refusal, or concession. That is the point of the machine.
 For game use, the loop should be able to emit:
 
 - a scene transcript
-- candidate player choices
+- candidate player choices, including speech and non-speech actions
 - NPC response branches
 - state/memory/social-perception deltas for each branch
 - unresolved hooks for later scenes
@@ -75,10 +81,32 @@ state for scene-local dialogue and action. If the scene itself is abstract and
 byzantine, the agent may still behave correctly inside that mess. Do not shove
 general prose quality or whole-plot design into this layer.
 
-## Action Selection
+## Branch Choices And Action Selection
 
 The action model must allow more than speech.
 
+For a protagonist scene, Ghostlight should be able to generate several
+plausible choices for what the protagonist can do next. For example, if Cat is
+interacting with another character, the generated choices might include:
+
+- say the honest thing badly
+- deflect with a joke
+- leave before the other person can answer
+- hand over evidence
+- hide evidence
+- accept help while pretending not to need it
+- threaten to walk
+- spend scarce money
+- break a device
+- touch someone gently
+- slap someone
+
+Those choices should come from Cat's state, scene affordances, resources,
+relationship pressure, and goals. They should not be generic verbs glued to a
+persona card. Each branch should carry expected consequence surfaces, such as
+trust risk, reputation risk, resource cost, information exposure, or future
+obligation.
+
 Keep the action vocabulary small and concrete. Do not turn every possible
 speech act into a separate tool. `ask`, `refuse`, `offer`, `reveal`, `conceal`,
 and `request authority action` are usually communicative intentions carried by
@@ -177,6 +205,21 @@ The resolver should decide:
 - which current activations changed
 - which options opened or closed
 
+In a branching scene tree, each branch should carry its own consequence packet.
+If Cat chooses to lie, accept help, shove someone, spend money, or reveal a
+secret, that branch should record what changed and what might matter later.
+Consequences can include:
+
+- trust lost or gained
+- suspicion raised or lowered
+- obligation created
+- debt created or paid
+- resource spent
+- information revealed or concealed
+- relationship rupture or repair
+- faction or reputation pressure changed
+- future scene hook opened or closed
+
 The first implementation can be conservative and partly deterministic. A bad
 resolver will build narrative sludge faster than a bad line of dialogue will.
 No pressure. Tiny little bear trap.
@@ -202,13 +245,13 @@ already learned human interpretation from twelve examples and a strong coffee.
 
 ## Scope Boundary
 
-Build interactive dialogue generation first, but shape the data for later
+Build interactive branching scene generation first, but shape the data for later
 open-world use.
 
 In scope now:
 
 - scene-local agent turns
-- player/NPC dialogue branches
+- player/NPC dialogue and action branches
 - local action proposals
 - event records
 - manual reviewed appraisals
@@ -242,8 +285,8 @@ Out of implementation scope for now:
 - automatic social appraisal rules pretending to be trained classifiers
 
 The eventual storyline generator, economic behavior model, and faction decision
-model should grow out of reliable scene machinery and reviewed decision data,
-not the other way around.
+model should grow out of reliable branching-scene machinery and reviewed
+decision data, not the other way around.
 
 ## Projection's Narrower Job
 
@@ -277,7 +320,7 @@ agent state + scene state
 
 The next implementation should not try to simulate a city. Calm down, wizard.
 
-Prototype one tiny dialogue-scene loop:
+Prototype one tiny branching-scene loop:
 
 1. Load `examples/agent-state.cold-wake-story-lab.json`.
 2. Select one scene and one acting agent.
@@ -298,5 +341,6 @@ Prototype one tiny dialogue-scene loop:
 
 The goal is not literary quality or autonomous plot generation. The goal is to
 prove that a character can drive a scene beat, produce branchable dialogue or
-action, and leave memory, relationship, social perception, and scene state
-slightly different behind them.
+non-dialogue action, trigger plausible responses from other characters, and
+leave memory, relationship, social perception, and scene state slightly
+different behind them.

notes/fresh-workspace-handoff.md

@@ -137,9 +137,9 @@ Remaining projection path:
 
 - build a deterministic speaker-local input slicer
 - build a renderer that emits projection controls before prompt prose
-- build the first scene-local dialogue tick so an agent can act from local
-  awareness, produce branchable dialogue or action, and mutate only the state it
-  has authority to affect
+- build the first scene-local branching tick so an agent can act from local
+  awareness, produce branchable speech or non-speech action, trigger NPC
+  responses, and mutate only the state it has authority to affect
 - keep the near-term product target to interactive dialogue trees and
   scene-local consequences
 - preserve training-data hooks for future open-world behavior, iterated

notes/ghostlight-current-system-map.md

@@ -48,8 +48,8 @@ state and re-entry discipline.
 - `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 dialogue consequences while preserving training hooks for later
-    open-world, economic, and faction decision models
+    branchable speech or non-speech scene consequences while preserving
+    training hooks for later open-world, economic, and faction decision models
 - `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

notes/ghostlight-implementation-plan.md

@@ -38,9 +38,9 @@
 4. Build the scene-local sequential dialogue loop. New target.
    - Use `docs/architecture/sequential-agent-runtime.md` as the first runtime
      contract.
-   - Keep the product target narrow: procedural interactive dialogue trees for
-     games first, then scene-local character action with consequence
-     propagation, then longer procedural storyline generation later.
+   - 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.
@@ -63,8 +63,12 @@
    - Keep author control at stage-setting and high-level constraints; do not
      require the author to script every beat.
    - Emit game-useful artifacts: scene transcript, candidate player choices,
-     NPC response branches, state/memory/social-perception deltas, and
-     unresolved hooks.
+     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

state/evidence.jsonl

@@ -32,3 +32,4 @@
 {"ts": "2026-05-01T22:18:59+00:00", "type": "design", "status": "accepted", "note": "Sequential runtime prototype should keep fuzzy interpretation manual at first. Action tools should be concrete primitives; ask/refuse/offer/reveal/conceal/request are intended communicative functions on actions, while listener appraisal may misread them. Manual appraisal and mutation review becomes training data for future classifiers."}
 {"ts": "2026-05-01T22:31:04+00:00", "type": "design", "status": "accepted", "note": "Tightened Ghostlight runtime scope: near-term goal is procedural interactive dialogue trees and scene-local consequence propagation into state, memory, and social perception. Sequential agent machinery should serve branchable game dialogue first; world-scale simulation, autonomous offscreen factions, economy, and long-horizon plot generation stay deferred."}
 {"ts": "2026-05-01T22:36:38+00:00", "type": "design", "status": "accepted", "note": "Adjusted scope boundary: implement scene-local interactive dialogue first, but shape training data for later open-world agents, iterated decisions, psychologically grounded consumer behavior, scarcity/reputation pressure, and major faction or institution decision-making. Defer full simulation loops, not the labels and state hooks those future models will need."}
+{"ts": "2026-05-01T22:40:18+00:00", "type": "design", "status": "accepted", "note": "Clarified that dialogue trees mean branching scene trees, not speech-only menus. Ghostlight should generate plausible protagonist speech or non-speech choices, NPC responses, and branch consequences in world state, memory, and social perception, such as losing trust or opening future hooks."}

state/map.yaml

@@ -10,8 +10,9 @@ experiment:
 objective:
   primary: >
     Turn Ghostlight into a legible machine for persistent socially aware
-    characters that can generate interactive dialogue trees for games, propagate
-    scene consequences into state and memory, and eventually support procedural
+    characters that can generate interactive branching scene trees for games,
+    including speech and non-speech actions, propagate scene consequences into
+    state and memory, and eventually support procedural
     storyline generation, psychologically grounded consumer behavior, and major
     faction decision-making without collapsing into prompt soup.
   current: >
@@ -104,9 +105,10 @@ accepted_design:
   - Generated action should become an event proposal resolved by mutation authority, not direct unrestricted edits to world or other-agent private state.
   - Sequential runtime action primitives should stay concrete; ask, refuse, offer, reveal, conceal, and request are communicative intentions carried by actions, while listener interpretation remains separate and may be wrong.
   - Early fuzzy social updates should be manual reviewed training data, not brittle rule-based appraisals pretending to understand relationships before the corpus exists.
-  - Scope boundary: implement interactive dialogue trees and scene-local consequences first, but preserve training data hooks for open-world contexts, iterated decisions, economic behavior, scarcity, reputation, faction pressure, and institution decision-making.
+  - Scope boundary: implement interactive branching scene trees and scene-local consequences first; dialogue trees include speech and non-speech actions, while preserving training data hooks for open-world contexts, iterated decisions, economic behavior, scarcity, reputation, faction pressure, and institution decision-making.
   - Do not train dialogue-only models that will be useless for later game-world simulation; reviewed scene data should preserve why agents buy, refuse, trade, hoard, comply, defect, conceal, punish, or help when those decisions appear.
+  - Branching scene generation should propose plausible protagonist choices, including speech, silence, movement, object use, concealment, revelation, withdrawal, violence, trade, or refusal, then record NPC responses and branch consequences such as trust loss or future hooks.
 
 current_status:
   summary: Ghostlight now has the Epiphany-style persistence spine, the first architecture payload, the v0 canonical agent-state schema seam, prompt projection docs, immediate schema fixes from evaluation, first reviewed Cat/Oz projection examples, a revised Aetheria lore-grounding architecture, a lore grounding digest schema, the first draft Cold Wake historical grounding digest, a Cold Wake story-lab fixture, projection controls, validated Qwen capture receipts, and a complete Cold Wake short story assembled from accepted projection outputs.
-  next_action: Build the first deterministic scene-local dialogue prototype: local awareness, projection controls, action/dialogue prompt, Qwen event proposal, conservative state mutation, and validation on one Cold Wake story-lab beat.
+  next_action: Build the first deterministic scene-local branching prototype: local awareness, projection controls, protagonist speech/action choices, NPC response generation, event proposals, conservative state mutation, and validation on one Cold Wake story-lab beat.