docs(codex): publish Build Small submission package

README.md

@@ -10,43 +10,160 @@ app_file: app.py
 fullWidth: true
 header: mini
 pinned: true
-short_description: Walk through a watercolor path of grounded encouragement.
+license: apache-2.0
+short_description: Turn a worry into a grounded, illustrated path forward.
 models:
 - build-small-hackathon/compliment-forest-minicpm5-1b
 - build-small-hackathon/compliment-forest-flux-lora
+- openbmb/MiniCPM4.1-8B
+- black-forest-labs/FLUX.1-schnell
+- thangvip/compliment-forest-watercolor-flux-lora-v2
+- thangvip/compliment-forest-paper-cut-flux-lora-v2
+- thangvip/compliment-forest-moonlit-gouache-flux-lora-v2
+- thangvip/compliment-forest-botanical-ink-flux-lora-v2
 datasets:
 - build-small-hackathon/compliment-forest-sft
 - build-small-hackathon/compliment-forest-watercolor
 - build-small-hackathon/compliment-forest-traces
+- thangvip/compliment-forest-multistyle-v2
 tags:
 - gradio
 - build-small-hackathon
-- local-first
-- watercolor
+- minicpm
+- modal
+- text-to-image
 - llama.cpp
+- track:backyard
+- sponsor:openbmb
+- sponsor:openai
+- sponsor:modal
+- achievement:welltuned
+- achievement:offbrand
+- achievement:llama
+- achievement:sharing
+- achievement:fieldnotes
 ---
 
 # The Compliment Forest
 
-Type a name and a situation, then walk through a progressive watercolor path.
-Each clearing pairs a creature with grounded encouragement, a reflection, and a
-copyable tiny spell.
+The Compliment Forest turns a worry into a five-chapter illustrated walk. It
+asks five adaptive questions, separates facts from fearful predictions, offers
+realistic options, suggests one small action, and ends with a simple plan the
+visitor can carry back into the day.
 
-The live Space uses the deterministic local demo backend so it remains fast and
-available on CPU hardware. The same application supports the published
-MiniCPM5-1B GGUF through a local `llama.cpp` server and FLUX.1-dev with the
-published watercolor LoRA by setting `CF_TEXT_BACKEND=llama_cpp` and
-`CF_IMAGE_BACKEND=flux`. No hosted inference API is called at runtime.
+This is whimsical encouragement, not therapy or a substitute for professional
+support. Crisis and acute-risk inputs stop before model generation and direct
+the visitor toward human help.
 
-## Published artifacts
+## Backyard AI: The Real Problem
 
-- Text model: `build-small-hackathon/compliment-forest-minicpm5-1b`
-- Text adapter: `build-small-hackathon/compliment-forest-minicpm5-1b-lora`
-- Text SFT data: `build-small-hackathon/compliment-forest-sft`
-- Watercolor LoRA: `build-small-hackathon/compliment-forest-flux-lora`
-- Watercolor data: `build-small-hackathon/compliment-forest-watercolor`
-- Linked-model traces: `build-small-hackathon/compliment-forest-traces`
+The Compliment Forest is built for the **Backyard AI** track. It addresses an
+everyday problem in modern society: people carry worries about test results,
+changing jobs, belonging, comparison, and an uncertain future, but the support
+they receive is often vague or disconnected from what actually happened.
 
-This is whimsical encouragement, not therapy or a substitute for professional
-support. Crisis and acute-risk inputs are routed to human support instead of
-generating a forest.
+The product gives a person a private place to explain one real concern in their
+own words. It asks what feels at stake, separates known facts from fearful
+predictions, and turns the conversation into understandable options and one
+small action. The illustrated forest makes that difficult reflection feel less
+clinical and easier to approach, while the practical content remains grounded
+in the person's situation.
+
+## Try It
+
+- Hackathon Space:
+  https://huggingface.co/spaces/build-small-hackathon/compliment-forest
+- Build article:
+  [Growing the Compliment Forest](docs/build-small-hackathon-article.md)
+- Demo script: [85-95 second recording plan](docs/demo-script.md)
+- Demo video: recording script is ready; public video link will be added here
+- Social post: publish-ready copy is ready; public post link will be added here
+
+## Why It Is AI-Native
+
+A fixed template cannot know whether a low test score hurts because of identity,
+comparison, uncertainty, or a specific learning gap. The forest uses an
+adaptive intake and a planner-author-critic pipeline to build a different path
+for each visitor.
+
+The five roles have distinct jobs:
+
+1. `arrive` acknowledges the feeling and concrete concern once.
+2. `steady` separates known facts from the outcome fear predicts.
+3. `widen` offers realistic interpretations or options.
+4. `step` gives one small, optional, low-risk action.
+5. `carry` leaves a simple plan or decision rule.
+
+Local validators reject repeated prose, repeated long source phrases, invented
+dates or actions, unsupported biography, stock abstraction, and a `step`
+chapter without practical help. Failed chapters are regenerated selectively.
+If repair still fails, the app tries one fresh forest and then returns an honest
+error instead of canned encouragement.
+
+## Small-Model Stack
+
+The live text and image stack is about 25B parameters in total, below the
+hackathon's 32B total limit.
+
+- **Text:** `openbmb/MiniCPM4.1-8B`, hosted on a Modal A100 endpoint.
+- **Images:** `black-forest-labs/FLUX.1-schnell` with four rank-16 style LoRAs,
+  hosted on a separate Modal A100 80GB endpoint.
+- **Local path:** the published 1.08B MiniCPM5 fine-tune is available as a
+  Q4_K_M GGUF through `llama.cpp`.
+- **Training:** the MiniCPM and FLUX adapters, validation runs, and deployment
+  experiments used Modal.
+
+Text and image inference scale independently. The canonical hackathon Space
+serves the custom interface and streams NDJSON progress. Because organization
+members cannot manage that Space's secrets, it forwards generation requests to
+the owner-controlled CPU orchestrator, which HMAC-signs calls to the two Modal
+services. No credential is stored in the public repository.
+
+## Published Artifacts
+
+- [MiniCPM5-1B fine-tune](https://huggingface.co/build-small-hackathon/compliment-forest-minicpm5-1b)
+- [MiniCPM text adapter](https://huggingface.co/build-small-hackathon/compliment-forest-minicpm5-1b-lora)
+- [Text SFT dataset](https://huggingface.co/datasets/build-small-hackathon/compliment-forest-sft)
+- [Watercolor FLUX LoRA](https://huggingface.co/build-small-hackathon/compliment-forest-flux-lora)
+- [Watercolor dataset](https://huggingface.co/datasets/build-small-hackathon/compliment-forest-watercolor)
+- [Sanitized linked-model traces](https://huggingface.co/datasets/build-small-hackathon/compliment-forest-traces)
+- [Multi-style dataset](https://huggingface.co/datasets/thangvip/compliment-forest-multistyle-v2)
+
+## Sponsor Work
+
+**OpenBMB:** MiniCPM is the core language model family for planning, authoring,
+critique, adaptive intake, and the published local fine-tune.
+
+**Modal:** Modal powered text and image inference, LoRA training, GGUF
+validation, and the independently scaling GPU endpoints used by the live app.
+
+**OpenAI Codex:** Codex was used throughout implementation and debugging:
+reading the codebase, writing tests, tracing malformed structured output,
+redesigning the prompt and quality gates, deploying Space revisions, and
+verifying full live flows.
+
+## Run Locally
+
+```bash
+uv sync --extra dev
+uv run python app.py
+```
+
+The default local backend is deterministic. To run the published local text
+model through `llama.cpp`:
+
+```bash
+CF_TEXT_BACKEND=llama_cpp
+CF_IMAGE_BACKEND=flux
+uv run --extra inference python app.py
+```
+
+## Verification
+
+```bash
+uv run pytest -q \
+  --ignore=tests/test_build_multistyle_dataset.py \
+  --ignore=tests/test_dataset_builder.py
+```
+
+Current maintained result: **155 passed**.

app.py

@@ -1,3 +1,4 @@
+import os
 import sys
 from pathlib import Path
 
@@ -6,9 +7,8 @@ sys.path.insert(0, str(Path(__file__).resolve().parent / "src"))
 from compliment_forest.server import create_app
 
 app = create_app()
-demo = app
 
-if __name__ == "__main__":
-    import uvicorn
-
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+if os.getenv("SPACE_ID"):
+    app.launch(show_error=True)
+elif __name__ == "__main__":
+    app.launch(server_name="0.0.0.0", server_port=7860)

docs/build-small-hackathon-article.md

@@ -0,0 +1,215 @@
+# Growing the Compliment Forest: Small Models, Honest Encouragement, and Five Clearings
+
+Most AI encouragement tools make the same mistake: they become vague exactly
+when the user needs something concrete.
+
+Someone writes, "I worry about my test score," and receives a polished cloud of
+phrases about believing in themselves, trusting the journey, or keeping their
+own pace. The words are kind, but they do not help the person understand the
+worry or decide what to do next.
+
+These are ordinary problems in modern society. Students can feel that one score
+defines their intelligence. Workers can feel trapped between an unhealthy job
+and fear of an uncertain search. Social comparison can turn one difficult
+moment into a judgment about an entire future.
+
+The Compliment Forest began with a different question:
+
+**Can a small model help someone understand one real worry and choose a useful
+next step without becoming generic or pretending to be a therapist?**
+
+The result is a Gradio application that turns a worry into a five-chapter,
+illustrated walk. It is whimsical on the surface, but its generation pipeline
+is deliberately strict underneath.
+
+## Why This Is Backyard AI
+
+We built The Compliment Forest for the **Backyard AI** track because it focuses
+on a common human problem close to home: people often need help making sense of
+school pressure, work uncertainty, belonging, comparison, or fear about what
+comes next. They may not need a grand solution. They need to feel understood,
+separate evidence from prediction, see realistic choices, and identify one
+manageable action.
+
+Generic reassurance does not solve that problem. Telling someone to believe in
+themselves may sound warm, but it does not help them decide whether to review a
+missed test question, identify a knowledge gap, ask for clearer expectations,
+or gather more information before making a job decision.
+
+The forest is designed to make that support easier to approach. The visual
+journey lowers the emotional barrier to reflection, while the model pipeline
+keeps the result tied to the person's own words. It does not promise that the
+worry will disappear. It helps the person leave with a clearer understanding
+and a small next move.
+
+## The Experience
+
+The visitor starts with a name and one sentence about what is troubling them.
+The forest then asks five adaptive multiple-choice questions. These questions
+stay focused on the actual problem:
+
+- What triggered the worry?
+- What feels most at stake?
+- When is it harder or easier?
+- What support or information would help?
+- What would count as a small win?
+
+After the visitor chooses an image style, the application generates five
+clearings:
+
+1. **Arrive:** acknowledge the feeling and concern.
+2. **Steady:** separate facts from the outcome fear predicts.
+3. **Widen:** offer realistic explanations or options.
+4. **Step:** suggest one small, optional action.
+5. **Carry:** leave a simple plan or rule to remember.
+
+Each clearing includes a scene, short narration, reflection, mantra, and a
+fresh illustration. The browser reveals them progressively rather than showing
+a wall of generated text.
+
+## Why a Planner-Author-Critic Pipeline?
+
+Free-form generation was not reliable enough for a sensitive experience.
+Larger prompts produced warmer prose, but they also encouraged plausible
+inventions: interviews the user never attended, applications they never sent,
+dates they never mentioned, or actions they never completed.
+
+The application therefore divides text generation into roles.
+
+The **planner** creates a conservative evidence plan. Every fact anchor must
+copy an exact phrase from the user's situation. A fear remains an uncertainty;
+it cannot silently become a fact.
+
+The **author** writes the five-chapter forest from that validated plan.
+
+The **critic** identifies chapters that are repetitive, unsupported, generic,
+or structurally weak.
+
+Python validators then enforce constraints that should not be delegated to
+prose judgment:
+
+- source phrases must occur in the user's input;
+- generated numbers and dates must be supported;
+- completed actions and biography cannot be invented;
+- long user sentences may be echoed only once;
+- clearings cannot substantially repeat one another;
+- stock abstract language is rejected;
+- the `step` clearing must contain practical help.
+
+When a chapter fails, the author rewrites only that chapter. Valid chapters are
+preserved exactly. If targeted repair still fails, the application requests one
+fresh full forest. If that also fails, it returns an honest error before image
+generation. It never replaces the result with canned encouragement.
+
+That last decision came from a real failure. An earlier safety fallback always
+returned five valid chapters, but every chapter repeated the user's sentence
+and surrounded it with abstract language. It looked polished and passed the
+schema, yet it failed the person. Removing that fallback made the system more
+honest and ultimately more useful.
+
+## Small Models, Different Jobs
+
+The live text path uses `openbmb/MiniCPM4.1-8B`. MiniCPM handles adaptive
+intake, evidence planning, authoring, and critique. Together with the roughly
+17B-parameter FLUX image stack, the live application is about 25B parameters in
+total and stays below the hackathon's 32B total cap.
+
+The project also publishes a 1.08B MiniCPM5 fine-tune trained on 1,500
+schema-validated examples. It was converted to a 688 MB Q4_K_M GGUF and
+smoke-tested with `llama.cpp`. That local path remains part of the same
+application for reproducible, off-grid experiments.
+
+Images use `FLUX.1-schnell` with four rank-16 LoRA adapters:
+
+- Watercolor Storybook
+- Layered Paper Cut
+- Moonlit Gouache
+- Botanical Ink Wash
+
+The multi-style dataset contains 160 generated examples balanced across
+animals, people, symbolic objects, and environments. Balancing subjects was
+important. The first dataset changed style successfully but produced too many
+animals, so the visual variety felt smaller than the style menu suggested.
+
+## Modal as the GPU Layer
+
+The canonical organization Space serves the custom interface and streams the
+API response. Since organization members cannot manage its secrets, it forwards
+generation requests to an owner-controlled CPU Space that holds the HMAC
+credential. Text and image workloads then run on separate Modal applications:
+
+- MiniCPM4.1-8B on an A100 40GB endpoint
+- FLUX.1-schnell plus the four style adapters on an A100 80GB endpoint
+
+This separation matters. Text planning and image rendering have different
+memory and scaling behavior. Keeping them in separate containers prevents one
+model from evicting the other and lets each service scale to zero
+independently. The public repository contains no credentials.
+
+Modal was also used for adapter training, validation grids, GGUF smoke tests,
+and deployment experiments. The runtime bridge signs requests with HMAC, and
+the organization Space preserves the NDJSON stream so a long generation
+remains visibly alive through both Hugging Face hops.
+
+## Codex as an Engineering Partner
+
+OpenAI Codex was used across the project rather than for one isolated code
+generation step.
+
+It read the architecture and handoff notes, traced production errors across the
+Space and Modal boundaries, wrote regression tests before fixes, strengthened
+JSON parsing, redesigned prompt contracts, calibrated deterministic quality
+checks, deployed Space revisions, and exercised full live user flows.
+
+The most useful Codex work was not producing more code. It was preserving the
+discipline to find root causes. A malformed critic response, a repeated intake
+question, an incomplete planner object, and a five-role survivor failure looked
+like separate bugs. Following their data flow showed a shared issue: strict
+model contracts need bounded repair, precise diagnostics, and deterministic
+validation at the right boundary.
+
+## Safety and Privacy
+
+The Compliment Forest is not therapy. A guard stops crisis, self-harm, abuse,
+and acute medical inputs before model calls and provides a human-support
+message.
+
+Public traces use fictional scenarios. Identity, situation text, secrets,
+tokens, and image payloads are not published. The trace dataset records the
+shape of planner-author-critic handoffs so others can inspect the architecture
+without exposing a visitor's private worry.
+
+## What I Learned
+
+**A schema is necessary, but not sufficient.** Perfect JSON can still contain
+bad help.
+
+**Concrete does not mean invented.** Useful advice can be specific while
+remaining conditional and grounded in the user's words.
+
+**Fallbacks can hide product failure.** A deterministic success response is
+worse than an honest retry when it erases personalization.
+
+**Small models improve when each call has one job.** Planning, writing, and
+critique are easier to validate than one giant prompt.
+
+**Pacing is part of model design.** Streaming one clearing at a time changes a
+slow generation into a walk.
+
+**Visual diversity needs subject diversity.** Four styles are not truly four
+experiences if every image contains the same kind of character.
+
+## Links
+
+- Space:
+  https://huggingface.co/spaces/build-small-hackathon/compliment-forest
+- MiniCPM5-1B model:
+  https://huggingface.co/build-small-hackathon/compliment-forest-minicpm5-1b
+- SFT dataset:
+  https://huggingface.co/datasets/build-small-hackathon/compliment-forest-sft
+- FLUX LoRA:
+  https://huggingface.co/build-small-hackathon/compliment-forest-flux-lora
+- Sanitized traces:
+  https://huggingface.co/datasets/build-small-hackathon/compliment-forest-traces
+- Multi-style dataset:
+  https://huggingface.co/datasets/thangvip/compliment-forest-multistyle-v2

docs/demo-script.md

@@ -0,0 +1,112 @@
+# The Compliment Forest Demo Script
+
+Target length: 85-95 seconds.
+
+Use a pre-generated completed forest for the final reveal. Record one real
+generation separately, then edit through the waiting periods so the video shows
+the complete product without pretending inference is instantaneous.
+
+## 0:00-0:08 - Hook
+
+**Screen:** Open on a completed Layered Paper Cut forest. Slowly scroll past two
+different clearings.
+
+**Voiceover:**
+
+> Most AI encouragement sounds kind, but says very little. The Compliment
+> Forest turns one real worry into a grounded, illustrated path forward.
+
+## 0:08-0:22 - Start With a Real Worry
+
+**Screen:** Return to the start. Enter:
+
+- Name: `Ka`
+- Situation: `I worry that one test score means I am not as smart as I thought.`
+
+Submit and show two adaptive questions with different selected answers.
+
+**Voiceover:**
+
+> I begin with one sentence. The forest asks five adaptive questions about
+> what happened, what feels at stake, and what useful progress would look like.
+> It does not ask me to choose a generic mood.
+
+## 0:22-0:31 - Choose the Visual Language
+
+**Screen:** Move quickly through the remaining answers. Select **Layered Paper
+Cut** and click **Grow my forest**.
+
+**Voiceover:**
+
+> Then I choose one of four LoRA-trained visual styles. Text and images run on
+> separate Modal GPU services, while the Hugging Face Space streams progress.
+
+## 0:31-0:58 - Show the Five-Chapter Arc
+
+**Screen:** Cut to the completed forest. Highlight each role title as the page
+scrolls:
+
+1. arrive
+2. steady
+3. widen
+4. step
+5. carry
+
+Pause longest on `step`. Show a sentence containing a concrete action such as
+reviewing one missed question or identifying one topic to practice.
+
+**Voiceover:**
+
+> MiniCPM plans from exact phrases in my input, writes five chapters, and
+> critiques them. The path first acknowledges the feeling, then separates facts
+> from fear, offers realistic options, gives one small action, and ends with a
+> simple plan.
+
+## 0:58-1:12 - Explain What Makes It Reliable
+
+**Screen:** Overlay a simple diagram:
+
+`adaptive intake -> planner -> author -> critic -> validators -> FLUX images`
+
+Then briefly show a test terminal with `155 passed`.
+
+**Voiceover:**
+
+> Local validators reject invented biography, repeated sentences, unsupported
+> dates, vague fallback language, and advice with no practical step. Bad
+> chapters are repaired selectively. If repair fails, the app returns an honest
+> retry instead of canned prose.
+
+## 1:12-1:24 - Show the Small-Model Work
+
+**Screen:** Show the Hugging Face model, dataset, LoRA, and trace cards in a
+quick four-panel montage.
+
+**Voiceover:**
+
+> The project also publishes a 1.08-billion-parameter MiniCPM fine-tune and
+> llama.cpp GGUF, four FLUX style adapters, training data, and sanitized
+> planner-author-critic traces.
+
+## 1:24-1:32 - Close
+
+**Screen:** Return to the full forest and its final mantra.
+
+**Voiceover:**
+
+> The Compliment Forest is whimsical encouragement with engineering boundaries:
+> small models, honest uncertainty, and one useful step back into the day.
+
+**End card:**
+
+`huggingface.co/spaces/build-small-hackathon/compliment-forest`
+
+## Recording Checklist
+
+- Record at 1440p or 1080p, 16:9.
+- Keep browser zoom near 90% so the custom interface remains readable.
+- Hide bookmarks, personal tabs, tokens, and terminal paths.
+- Use captions for every voiceover line.
+- Do not show a crisis phrase in the main demo; mention the safety boundary in
+  the article and README so the product story stays focused.
+- Export a thumbnail from the completed paper-cut forest.

docs/social-post.md

@@ -0,0 +1,47 @@
+# Social Post Drafts
+
+Replace `[VIDEO URL]` after uploading the demo.
+
+## LinkedIn / Hugging Face Community
+
+I built **The Compliment Forest** for the Hugging Face Build Small Hackathon.
+
+Most AI encouragement becomes abstract when a person needs something concrete.
+The Compliment Forest turns one worry into a five-chapter illustrated walk:
+acknowledge the feeling, separate facts from fear, consider realistic options,
+choose one small action, and carry a simple plan forward.
+
+The stack:
+
+- MiniCPM4.1-8B for adaptive intake, planning, authoring, and critique
+- a published 1.08B MiniCPM fine-tune and llama.cpp GGUF
+- FLUX.1-schnell with four LoRA-trained visual styles
+- separate Modal GPU services for text and image inference
+- a custom Gradio Server frontend on Hugging Face Spaces
+- deterministic validators for grounding, repetition, invented biography, and
+  practical advice
+
+OpenAI Codex helped across the full engineering loop: codebase exploration,
+test-first debugging, structured-output repair, prompt redesign, deployment,
+and live verification.
+
+Try it:
+https://huggingface.co/spaces/build-small-hackathon/compliment-forest
+
+Demo: [VIDEO URL]
+
+#BuildSmall #HuggingFace #MiniCPM #Modal #OpenAICodex #Gradio #GenerativeAI
+
+## X / Bluesky
+
+I built The Compliment Forest for #BuildSmall: one worry becomes a grounded,
+five-chapter illustrated path with MiniCPM, FLUX LoRAs, Modal, a custom Gradio
+UI, and strict checks against repeated or invented advice.
+
+Space:
+https://huggingface.co/spaces/build-small-hackathon/compliment-forest
+
+Demo: [VIDEO URL]
+
+#HuggingFace #MiniCPM #OpenAICodex
+

frontend/app.js

@@ -3,17 +3,28 @@
 const entryView = document.querySelector("#entry-view");
 const experienceView = document.querySelector("#experience-view");
 const form = document.querySelector("#forest-form");
+const formSteps = Array.from(document.querySelectorAll(".form-step"));
+const stepTracker = document.querySelector("#step-tracker");
 const nameInput = document.querySelector("#name");
 const situationInput = document.querySelector("#situation");
+const styleInput = document.querySelector("#style");
 const growButton = document.querySelector("#grow-button");
 const statusRegion = document.querySelector("#status-region");
+const intakeStep = document.querySelector("#intake-step");
+const intakeQuestion = document.querySelector("#intake-question");
+const intakeOptions = document.querySelector("#intake-options");
+const intakeProgress = document.querySelector("#intake-progress");
+const styleStep = document.querySelector("#style-step");
 const forestTitle = document.querySelector("#forest-title");
 const clearingProgress = document.querySelector("#clearing-progress");
+const artStyleLabel = document.querySelector("#art-style-label");
 const progressDots = document.querySelector("#progress-dots");
+const soundscapePlayer = document.querySelector("#soundscape-player");
+const soundscapeAudio = document.querySelector("#soundscape-audio");
 const clearingImage = document.querySelector("#clearing-image");
-const creature = document.querySelector("#creature");
-const strength = document.querySelector("#strength");
-const encouragement = document.querySelector("#encouragement");
+const sceneTitle = document.querySelector("#scene-title");
+const sceneIntro = document.querySelector("#scene-intro");
+const narration = document.querySelector("#narration");
 const reflection = document.querySelector("#reflection");
 const spell = document.querySelector("#spell");
 const copySpell = document.querySelector("#copy-spell");
@@ -22,45 +33,269 @@ const saveForest = document.querySelector("#save-forest");
 const startOver = document.querySelector("#start-over");
 const brandHome = document.querySelector("#brand-home");
 
+const INTAKE_TURNS = 5;
+
+const STYLE_LABELS = {
+  watercolor: "Watercolor Storybook",
+  paper_cut: "Layered Paper Cut",
+  moonlit_gouache: "Moonlit Gouache",
+  botanical_ink: "Botanical Ink Wash",
+};
+
 const state = {
   forestTitle: "",
   clearingCount: 0,
   clearings: [],
   currentIndex: 0,
+  currentStep: "name",
+  intake: [],
+  pendingQuestion: null,
   complete: false,
   name: "",
   situation: "",
+  style: "surprise",
+  resolvedStyle: "",
+  seed: 0,
 };
 
+function randomSeed() {
+  const values = new Uint32Array(1);
+  crypto.getRandomValues(values);
+  return values[0] % 2147483648;
+}
+
+function setStatus(message, isError = false) {
+  statusRegion.textContent = message;
+  statusRegion.classList.toggle("is-error", isError);
+}
+
+function updateStepTracker() {
+  const items = Array.from(stepTracker.querySelectorAll("li"));
+  let currentSlot;
+  if (state.currentStep === "name") currentSlot = 0;
+  else if (state.currentStep === "style") currentSlot = 6;
+  else if (state.currentStep === "intake") currentSlot = 1 + state.intake.length;
+  else currentSlot = 0;
+  for (const [index, item] of items.entries()) {
+    item.classList.toggle("is-current", index === currentSlot);
+    item.classList.toggle("is-complete", index < currentSlot);
+  }
+}
+
+function showStep(step, focus = true) {
+  state.currentStep = step;
+  const lookup = {
+    name: '[data-step="0"]',
+    intake: '[data-step="intake"]',
+    style: '[data-step="style"]',
+  };
+  for (const section of formSteps) {
+    section.hidden = true;
+    section.classList.remove("is-active");
+  }
+  const active = document.querySelector(lookup[step]);
+  if (active) {
+    active.hidden = false;
+    active.classList.add("is-active");
+    if (focus) {
+      const target = active.querySelector("input, textarea, button, select");
+      if (target) target.focus({ preventScroll: true });
+    }
+  }
+  updateStepTracker();
+}
+
 function resetState() {
   state.forestTitle = "";
   state.clearingCount = 0;
   state.clearings = [];
   state.currentIndex = 0;
+  state.intake = [];
+  state.pendingQuestion = null;
   state.complete = false;
+  state.resolvedStyle = "";
   statusRegion.textContent = "";
   statusRegion.classList.remove("is-error");
+  artStyleLabel.textContent = "";
+  soundscapeAudio.pause();
+  soundscapeAudio.removeAttribute("src");
+  soundscapeAudio.load();
+  soundscapePlayer.hidden = true;
   saveForest.hidden = true;
   walkOn.hidden = false;
   walkOn.disabled = false;
   walkOn.querySelector("span").textContent = "Walk on";
 }
 
-function showEntry() {
-  resetState();
-  experienceView.hidden = true;
-  entryView.hidden = false;
-  growButton.disabled = false;
-  growButton.querySelector("span").textContent = "Grow my forest";
-  window.scrollTo({ top: 0, behavior: "smooth" });
-  nameInput.focus();
+function renderIntakeQuestion(question) {
+  state.pendingQuestion = question;
+  intakeProgress.textContent = `Question ${state.intake.length + 1} of ${INTAKE_TURNS}`;
+  intakeQuestion.textContent = question.question;
+  intakeOptions.replaceChildren();
+  for (const option of question.options) {
+    const label = document.createElement("label");
+    label.className = "choice-card";
+    const sanitized = option.replace(/"/g, "&quot;");
+    label.innerHTML = `
+      <input type="radio" name="intake-option" value="${sanitized}" />
+      <span>${option}</span>
+    `;
+    intakeOptions.append(label);
+  }
 }
 
-function setStatus(message, isError = false) {
-  statusRegion.textContent = message;
-  statusRegion.classList.toggle("is-error", isError);
+async function fetchNextIntakeQuestion() {
+  setStatus("The forest is listening… (first response can take ~60s while it wakes)");
+  let response;
+  try {
+    response = await fetch("/api/intake/next", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        name: state.name,
+        situation: state.situation,
+        history: state.intake,
+      }),
+    });
+  } catch (networkError) {
+    throw new Error(
+      `Could not reach the forest (network): ${networkError.message}`,
+    );
+  }
+  if (!response.ok) {
+    let detail = "";
+    try {
+      const body = await response.json();
+      detail = body && body.detail ? body.detail : JSON.stringify(body);
+    } catch {
+      detail = await response.text().catch(() => "");
+    }
+    throw new Error(
+      `The forest is too quiet (HTTP ${response.status}): ${detail.slice(0, 800)}`,
+    );
+  }
+  const question = await response.json();
+  setStatus("The forest has a question for you.");
+  return question;
+}
+
+async function startIntake() {
+  state.name = nameInput.value.trim();
+  state.situation = situationInput.value.trim();
+  state.intake = [];
+  showStep("intake");
+  await advanceIntake();
+}
+
+async function advanceIntake() {
+  if (state.intake.length >= INTAKE_TURNS) {
+    showStep("style");
+    setStatus("");
+    return;
+  }
+  try {
+    const question = await fetchNextIntakeQuestion();
+    renderIntakeQuestion(question);
+  } catch (error) {
+    setStatus(error.message, true);
+  }
+}
+
+function validateNameStep() {
+  for (const input of [nameInput, situationInput]) {
+    if (!input.checkValidity()) {
+      input.reportValidity();
+      return false;
+    }
+  }
+  return true;
+}
+
+function validateIntakeChoice() {
+  const checked = intakeOptions.querySelector('input[name="intake-option"]:checked');
+  if (!checked) {
+    setStatus("Choose one option before walking on.", true);
+    return null;
+  }
+  setStatus("");
+  return checked.value;
+}
+
+for (const button of document.querySelectorAll(".step-next")) {
+  button.addEventListener("click", async () => {
+    if (state.currentStep === "name") {
+      if (!validateNameStep()) return;
+      await startIntake();
+      return;
+    }
+    if (state.currentStep === "intake") {
+      const answer = validateIntakeChoice();
+      if (!answer || !state.pendingQuestion) return;
+      state.intake.push({ question: state.pendingQuestion.question, answer });
+      state.pendingQuestion = null;
+      updateStepTracker();
+      await advanceIntake();
+      return;
+    }
+  });
 }
 
+for (const button of document.querySelectorAll(".step-back")) {
+  button.addEventListener("click", async () => {
+    if (state.currentStep === "intake") {
+      if (state.intake.length === 0) {
+        showStep("name");
+        return;
+      }
+      state.intake.pop();
+      state.pendingQuestion = null;
+      updateStepTracker();
+      await advanceIntake();
+      return;
+    }
+    if (state.currentStep === "style") {
+      // Drop the last answer so advanceIntake re-asks instead of bouncing back to style.
+      if (state.intake.length > 0) state.intake.pop();
+      state.pendingQuestion = null;
+      showStep("intake");
+      updateStepTracker();
+      await advanceIntake();
+    }
+  });
+}
+
+form.addEventListener("submit", async (submitEvent) => {
+  submitEvent.preventDefault();
+  if (state.currentStep !== "style") return;
+  state.style = styleInput.value;
+  state.seed = randomSeed();
+  growButton.disabled = true;
+  growButton.querySelector("span").textContent = "Growing your path";
+  setStatus("The forest is shaping the walk you talked about.");
+
+  try {
+    const response = await fetch("/api/forest", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        name: state.name,
+        situation: state.situation,
+        style: state.style,
+        seed: state.seed,
+        intake: state.intake,
+      }),
+    });
+    await readForestStream(response);
+  } catch (error) {
+    setStatus(
+      error.message || "The forest could not begin. Please try again.",
+      true,
+    );
+    growButton.disabled = false;
+    growButton.querySelector("span").textContent = "Grow my forest";
+  }
+});
+
 function buildDots() {
   progressDots.replaceChildren();
   const count = state.clearingCount || state.clearings.length;
@@ -81,7 +316,19 @@ function updateActions() {
   walkOn.hidden = atFinalEnd;
   saveForest.hidden = !atFinalEnd;
   walkOn.disabled = !hasNext;
-  walkOn.querySelector("span").textContent = hasNext ? "Walk on" : "Painting the next clearing";
+  walkOn.querySelector("span").textContent = hasNext
+    ? "Walk on"
+    : "Painting the next clearing";
+}
+
+function renderNarration(text) {
+  narration.replaceChildren();
+  const paragraphs = text.split(/\n{2,}/).map((piece) => piece.trim()).filter(Boolean);
+  for (const paragraph of paragraphs) {
+    const node = document.createElement("p");
+    node.textContent = paragraph;
+    narration.append(node);
+  }
 }
 
 function renderCurrent() {
@@ -94,11 +341,18 @@ function renderCurrent() {
   clearingProgress.textContent = `Clearing ${state.currentIndex + 1} of ${
     state.clearingCount || state.clearings.length
   }`;
-  clearingImage.src = item.image || "/assets/fox-path.png";
-  clearingImage.alt = item.clearing.creature;
-  creature.textContent = item.clearing.creature;
-  strength.textContent = item.clearing.strength;
-  encouragement.textContent = item.clearing.line;
+  if (item.image) {
+    clearingImage.src = item.image;
+    clearingImage.alt = item.clearing.scene_title;
+    clearingImage.hidden = false;
+  } else {
+    clearingImage.removeAttribute("src");
+    clearingImage.alt = "";
+    clearingImage.hidden = true;
+  }
+  sceneTitle.textContent = item.clearing.scene_title;
+  sceneIntro.textContent = item.clearing.scene_intro;
+  renderNarration(item.clearing.narration);
   reflection.textContent = item.clearing.reflection;
   spell.textContent = item.clearing.spell;
   buildDots();
@@ -120,6 +374,10 @@ function handleEvent(event) {
   if (event.type === "forest") {
     state.forestTitle = event.data.forest_title;
     state.clearingCount = event.data.clearing_count || 0;
+    state.resolvedStyle = event.data.style || "";
+    artStyleLabel.textContent = state.resolvedStyle
+      ? `Painted in ${STYLE_LABELS[state.resolvedStyle] || state.resolvedStyle}`
+      : "";
     setStatus("The first clearing is almost in view.");
     return;
   }
@@ -132,6 +390,11 @@ function handleEvent(event) {
     }
     return;
   }
+  if (event.type === "soundscape") {
+    soundscapeAudio.src = event.data.audio;
+    soundscapePlayer.hidden = false;
+    return;
+  }
   if (event.type === "complete") {
     state.complete = true;
     updateActions();
@@ -161,34 +424,6 @@ async function readForestStream(response) {
   if (buffer.trim()) handleEvent(JSON.parse(buffer));
 }
 
-form.addEventListener("submit", async (submitEvent) => {
-  submitEvent.preventDefault();
-  if (!form.reportValidity()) return;
-
-  resetState();
-  state.name = nameInput.value.trim();
-  state.situation = situationInput.value.trim();
-  growButton.disabled = true;
-  growButton.querySelector("span").textContent = "Growing your path";
-  setStatus("The forest is listening.");
-
-  try {
-    const response = await fetch("/api/forest", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        name: state.name,
-        situation: state.situation,
-      }),
-    });
-    await readForestStream(response);
-  } catch (error) {
-    setStatus(error.message || "The forest could not begin. Please try again.", true);
-    growButton.disabled = false;
-    growButton.querySelector("span").textContent = "Grow my forest";
-  }
-});
-
 walkOn.addEventListener("click", () => {
   if (state.currentIndex + 1 >= state.clearings.length) return;
   state.currentIndex += 1;
@@ -204,26 +439,126 @@ copySpell.addEventListener("click", async () => {
   }, 1600);
 });
 
-function wrapText(context, text, x, y, maxWidth, lineHeight, maxLines = 4) {
-  const words = text.split(/\s+/);
+function splitOversizeWord(context, word, maxWidth) {
+  if (context.measureText(word).width <= maxWidth) return [word];
+  const pieces = [];
+  let piece = "";
+  for (const character of word) {
+    const next = piece + character;
+    if (piece && context.measureText(next).width > maxWidth) {
+      pieces.push(piece);
+      piece = character;
+    } else {
+      piece = next;
+    }
+  }
+  if (piece) pieces.push(piece);
+  return pieces;
+}
+
+function wrapTextLines(context, text, maxWidth) {
+  const words = text
+    .trim()
+    .split(/\s+/)
+    .flatMap((word) => splitOversizeWord(context, word, maxWidth));
+  const lines = [];
   let line = "";
-  let lineCount = 0;
   for (const word of words) {
     const next = line ? `${line} ${word}` : word;
     if (context.measureText(next).width > maxWidth && line) {
-      context.fillText(line, x, y + lineCount * lineHeight);
+      lines.push(line);
       line = word;
-      lineCount += 1;
-      if (lineCount >= maxLines) return y + lineCount * lineHeight;
     } else {
       line = next;
     }
   }
-  if (line && lineCount < maxLines) {
-    context.fillText(line, x, y + lineCount * lineHeight);
-    lineCount += 1;
+  if (line) lines.push(line);
+  return lines.length ? lines : [""];
+}
+
+function drawWrappedText(context, lines, x, y, lineHeight) {
+  for (const [index, line] of lines.entries()) {
+    context.fillText(line, x, y + index * lineHeight);
   }
-  return y + lineCount * lineHeight;
+  return y + lines.length * lineHeight;
+}
+
+function measureTextBlock(context, text, font, maxWidth, lineHeight) {
+  context.font = font;
+  const lines = wrapTextLines(context, text, maxWidth);
+  return { font, lines, lineHeight, height: lines.length * lineHeight };
+}
+
+function measureForestCardLayout(context) {
+  const textWidth = 800;
+  const title = measureTextBlock(
+    context,
+    state.forestTitle,
+    '58px "Iowan Old Style", Georgia, serif',
+    1180,
+    66,
+  );
+  const headerHeight =
+    178 + Math.max(0, title.lines.length - 1) * title.lineHeight;
+  let top = headerHeight + 28;
+  const rows = state.clearings.map((item) => {
+    const sceneBlock = measureTextBlock(
+      context,
+      item.clearing.scene_title.toUpperCase(),
+      '600 17px "Avenir Next", Arial, sans-serif',
+      textWidth,
+      24,
+    );
+    const introBlock = measureTextBlock(
+      context,
+      item.clearing.scene_intro,
+      'italic 22px "Iowan Old Style", Georgia, serif',
+      textWidth,
+      30,
+    );
+    const narrationBlock = measureTextBlock(
+      context,
+      item.clearing.narration.replace(/\n+/g, " "),
+      '28px "Iowan Old Style", Georgia, serif',
+      textWidth,
+      38,
+    );
+    const spellBlock = measureTextBlock(
+      context,
+      item.clearing.spell,
+      '25px "Iowan Old Style", Georgia, serif',
+      textWidth,
+      34,
+    );
+    const textHeight =
+      24 +
+      sceneBlock.height +
+      8 +
+      introBlock.height +
+      18 +
+      narrationBlock.height +
+      36 +
+      spellBlock.height +
+      18;
+    const height = Math.max(360, textHeight);
+    const row = {
+      item,
+      top,
+      height,
+      sceneBlock,
+      introBlock,
+      narrationBlock,
+      spellBlock,
+    };
+    top += height + 38;
+    return row;
+  });
+  return {
+    title,
+    headerHeight,
+    rows,
+    height: top + 92,
+  };
 }
 
 function loadImage(source) {
@@ -237,12 +572,13 @@ function loadImage(source) {
 
 async function drawForestCard() {
   const width = 1400;
-  const rowHeight = 360;
-  const height = 300 + state.clearings.length * rowHeight + 150;
   const canvas = document.createElement("canvas");
   canvas.width = width;
-  canvas.height = height;
-  const context = canvas.getContext("2d");
+  let context = canvas.getContext("2d");
+  const layout = measureForestCardLayout(context);
+  canvas.height = layout.height;
+  context = canvas.getContext("2d");
+  const height = layout.height;
 
   context.fillStyle = "#f5f0df";
   context.fillRect(0, 0, width, height);
@@ -257,45 +593,92 @@ async function drawForestCard() {
 
   context.fillStyle = "#243c31";
   context.textAlign = "center";
-  context.font = '58px "Iowan Old Style", Georgia, serif';
-  context.fillText(state.forestTitle, width / 2, 92);
+  context.font = layout.title.font;
+  drawWrappedText(
+    context,
+    layout.title.lines,
+    width / 2,
+    92,
+    layout.title.lineHeight,
+  );
   context.font = '22px "Avenir Next", Arial, sans-serif';
-  context.fillText("A path from The Compliment Forest", width / 2, 138);
+  const subtitleY =
+    138 + Math.max(0, layout.title.lines.length - 1) * layout.title.lineHeight;
+  context.fillText("A path from The Compliment Forest", width / 2, subtitleY);
+  if (state.resolvedStyle) {
+    context.font = '18px "Avenir Next", Arial, sans-serif';
+    context.fillStyle = "#3f5634";
+    context.fillText(
+      `Painted in ${STYLE_LABELS[state.resolvedStyle] || state.resolvedStyle}`,
+      width / 2,
+      subtitleY + 32,
+    );
+  }
   context.textAlign = "left";
 
-  for (let index = 0; index < state.clearings.length; index += 1) {
-    const item = state.clearings[index];
-    const top = 205 + index * rowHeight;
+  for (const row of layout.rows) {
+    const { item, top } = row;
     try {
-      const image = await loadImage(item.image || "/assets/fox-path.png");
-      context.save();
-      context.beginPath();
-      context.roundRect(80, top, 350, 280, 20);
-      context.clip();
-      context.drawImage(image, 80, top, 350, 280);
-      context.restore();
+      if (item.image) {
+        const image = await loadImage(item.image);
+        context.save();
+        context.beginPath();
+        context.roundRect(80, top, 350, 280, 20);
+        context.clip();
+        context.drawImage(image, 80, top, 350, 280);
+        context.restore();
+      } else {
+        throw new Error("No generated image");
+      }
     } catch {
       context.fillStyle = "#d8ddc8";
       context.fillRect(80, top, 350, 280);
     }
 
     context.fillStyle = "#3f5634";
-    context.font = '600 17px "Avenir Next", Arial, sans-serif';
-    context.fillText(item.clearing.creature.toUpperCase(), 490, top + 24);
-    context.font = '39px "Iowan Old Style", Georgia, serif';
-    context.fillText(item.clearing.strength, 490, top + 72);
+    context.font = row.sceneBlock.font;
+    let textY = drawWrappedText(
+      context,
+      row.sceneBlock.lines,
+      490,
+      top + 24,
+      row.sceneBlock.lineHeight,
+    );
+    textY += 8;
+    context.fillStyle = "#4c574f";
+    context.font = row.introBlock.font;
+    textY = drawWrappedText(
+      context,
+      row.introBlock.lines,
+      490,
+      textY,
+      row.introBlock.lineHeight,
+    );
+    textY += 18;
     context.fillStyle = "#243c31";
-    context.font = '31px "Iowan Old Style", Georgia, serif';
-    let textY = wrapText(context, item.clearing.line, 490, top + 123, 800, 41, 3);
+    context.font = row.narrationBlock.font;
+    textY = drawWrappedText(
+      context,
+      row.narrationBlock.lines,
+      490,
+      textY,
+      row.narrationBlock.lineHeight,
+    );
     context.strokeStyle = "rgba(83,104,61,0.45)";
     context.lineWidth = 2;
     context.beginPath();
     context.moveTo(490, textY + 18);
     context.lineTo(1290, textY + 18);
     context.stroke();
-    context.font = '25px "Iowan Old Style", Georgia, serif';
+    context.font = row.spellBlock.font;
     context.fillStyle = "#3f5634";
-    wrapText(context, item.clearing.spell, 490, textY + 62, 800, 34, 2);
+    drawWrappedText(
+      context,
+      row.spellBlock.lines,
+      490,
+      textY + 62,
+      row.spellBlock.lineHeight,
+    );
   }
 
   context.textAlign = "center";
@@ -324,6 +707,18 @@ saveForest.addEventListener("click", async () => {
   }, "image/png");
 });
 
+function showEntry() {
+  resetState();
+  form.reset();
+  showStep("name", false);
+  experienceView.hidden = true;
+  entryView.hidden = false;
+  growButton.disabled = false;
+  growButton.querySelector("span").textContent = "Grow my forest";
+  window.scrollTo({ top: 0, behavior: "smooth" });
+  nameInput.focus();
+}
+
 startOver.addEventListener("click", showEntry);
 brandHome.addEventListener("click", showEntry);
-
+showStep("name", false);

frontend/index.html

@@ -1,143 +1,302 @@
 <!doctype html>
 <html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <meta
-      name="description"
-      content="A small-model-powered path of grounded, illustrated encouragement."
-    />
-    <title>The Compliment Forest</title>
-    <link rel="stylesheet" href="/styles.css" />
-  </head>
-  <body>
-    <div class="paper-grain" aria-hidden="true"></div>
-    <div class="fireflies" aria-hidden="true">
-      <i></i><i></i><i></i><i></i><i></i>
-    </div>
-
-    <header class="site-header">
-      <button class="brand" id="brand-home" type="button" aria-label="Return to the beginning">
-        <svg class="brand-mark" viewBox="0 0 64 64" aria-hidden="true">
-          <path d="M16 48C5 35 10 16 27 10c15-5 30 4 31 20 1 18-18 29-34 21" />
-          <path d="M18 45c10-17 21-24 35-27M17 20c6 1 10 4 13 9M34 11c0 6 2 10 7 14" />
-          <ellipse cx="13" cy="35" rx="3" ry="7" transform="rotate(-31 13 35)" />
-          <ellipse cx="24" cy="16" rx="3" ry="7" transform="rotate(34 24 16)" />
-          <ellipse cx="48" cy="16" rx="3" ry="7" transform="rotate(57 48 16)" />
-          <ellipse cx="53" cy="37" rx="3" ry="7" transform="rotate(102 53 37)" />
-        </svg>
-        <span>The Compliment Forest</span>
-      </button>
-    </header>
-
-    <main id="app">
-      <section class="view entry-view" id="entry-view">
-        <div class="entry-copy">
-          <h1>The Compliment<br />Forest</h1>
-          <p class="intro">
-            Name what you're carrying. We'll walk until a few quiet strengths find you.
-          </p>
-
-          <form id="forest-form" novalidate>
-            <label for="name">Your name</label>
-            <input
-              id="name"
-              name="name"
-              type="text"
-              placeholder="Mika"
-              autocomplete="name"
-              maxlength="80"
-              required
-            />
-
-            <label for="situation">What's happening?</label>
-            <textarea
-              id="situation"
-              name="situation"
-              placeholder="Starting a new job, and worried I won't belong..."
-              maxlength="1200"
-              rows="4"
-              required
-            ></textarea>
-
-            <button class="primary-button grow-button" id="grow-button" type="submit">
-              <span>Grow my forest</span>
-              <svg viewBox="0 0 32 20" aria-hidden="true">
-                <path d="M2 10h24M19 3l8 7-8 7M13 8c-4-5-8-4-9-2 4 1 7 3 9 6" />
-              </svg>
-            </button>
-          </form>
-
-          <div
-            class="status-region"
-            id="status-region"
-            role="status"
-            aria-live="polite"
-            aria-atomic="true"
-          ></div>
+    <head>
+        <meta charset="utf-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        <meta
+            name="description"
+            content="A guided, small-model-powered path of grounded, illustrated encouragement."
+        />
+        <title>The Compliment Forest</title>
+        <link rel="stylesheet" href="/styles.css" />
+    </head>
+    <body>
+        <div class="paper-grain" aria-hidden="true"></div>
+        <div class="fireflies" aria-hidden="true">
+            <i></i><i></i><i></i><i></i><i></i>
         </div>
 
-        <figure class="entry-art">
-          <img src="/assets/fox-path.png" alt="" />
-        </figure>
-      </section>
+        <header class="site-header">
+            <button
+                class="brand"
+                id="brand-home"
+                type="button"
+                aria-label="Return to the beginning"
+            >
+                <svg class="brand-mark" viewBox="0 0 64 64" aria-hidden="true">
+                    <path
+                        d="M16 48C5 35 10 16 27 10c15-5 30 4 31 20 1 18-18 29-34 21"
+                    />
+                    <path
+                        d="M18 45c10-17 21-24 35-27M17 20c6 1 10 4 13 9M34 11c0 6 2 10 7 14"
+                    />
+                    <ellipse
+                        cx="13"
+                        cy="35"
+                        rx="3"
+                        ry="7"
+                        transform="rotate(-31 13 35)"
+                    />
+                    <ellipse
+                        cx="24"
+                        cy="16"
+                        rx="3"
+                        ry="7"
+                        transform="rotate(34 24 16)"
+                    />
+                    <ellipse
+                        cx="48"
+                        cy="16"
+                        rx="3"
+                        ry="7"
+                        transform="rotate(57 48 16)"
+                    />
+                    <ellipse
+                        cx="53"
+                        cy="37"
+                        rx="3"
+                        ry="7"
+                        transform="rotate(102 53 37)"
+                    />
+                </svg>
+                <span>The Compliment Forest</span>
+            </button>
+        </header>
+
+        <main id="app">
+            <section class="view entry-view" id="entry-view">
+                <div class="entry-copy">
+                    <p class="eyebrow">A private-feeling guided walk</p>
+                    <h1>The Compliment<br />Forest</h1>
+                    <p class="intro">
+                        Name what you're carrying. The forest is listening before it asks five
+                        quiet questions, then walks a path with you.
+                    </p>
 
-      <section class="view experience-view" hidden id="experience-view">
-        <div class="path-header">
-          <h1 id="forest-title">A path is growing</h1>
-          <p id="clearing-progress">Clearing 1</p>
-          <div class="progress-dots" id="progress-dots" aria-hidden="true"></div>
-        </div>
+                    <form id="forest-form" novalidate>
+                        <ol class="step-tracker" id="step-tracker" aria-label="Forest intake progress">
+                            <li class="is-current">Name it</li>
+                            <li>Question 1 of 5</li>
+                            <li>Question 2 of 5</li>
+                            <li>Question 3 of 5</li>
+                            <li>Question 4 of 5</li>
+                            <li>Question 5 of 5</li>
+                            <li>Paint it</li>
+                        </ol>
+
+                        <section class="form-step is-active" data-step="0">
+                            <p class="step-kicker">Step 1 of 5</p>
+                            <h2>What should the forest call you?</h2>
+
+                            <label for="name">Your name</label>
+                            <input
+                                id="name"
+                                name="name"
+                                type="text"
+                                placeholder="Mika"
+                                autocomplete="name"
+                                maxlength="80"
+                                required
+                            />
+
+                            <label for="situation"
+                                >What are you carrying right now?</label
+                            >
+                            <textarea
+                                id="situation"
+                                name="situation"
+                                placeholder="Starting a new job, and worried I won't belong..."
+                                maxlength="1200"
+                                rows="4"
+                                required
+                            ></textarea>
+
+                            <div class="step-actions">
+                                <button
+                                    class="primary-button step-next"
+                                    type="button"
+                                >
+                                    Begin the walk
+                                </button>
+                            </div>
+                        </section>
+
+                        <section class="form-step" data-step="intake" id="intake-step" hidden>
+                            <p class="step-kicker" id="intake-progress">Question 1 of 5</p>
+                            <h2 id="intake-question">The forest is listening for your first question.</h2>
+                            <p class="step-help">Pick the option that comes closest. The next question adapts.</p>
+
+                            <div
+                                class="choice-grid two-column"
+                                id="intake-options"
+                                role="radiogroup"
+                                aria-label="Forest question"
+                            ></div>
+
+                            <div class="step-actions split-actions">
+                                <button class="text-button step-back" type="button">Back</button>
+                                <button class="primary-button step-next" type="button">
+                                    Walk on
+                                </button>
+                            </div>
+                        </section>
 
-        <article class="clearing">
-          <figure class="clearing-art">
-            <div class="image-wash" aria-hidden="true"></div>
-            <img id="clearing-image" src="" alt="" />
-          </figure>
+                        <section class="form-step" data-step="style" id="style-step" hidden>
+                            <p class="step-kicker">Painting the path</p>
+                            <h2>How should the forest paint your walk?</h2>
 
-          <div class="clearing-copy">
-            <p class="creature" id="creature"></p>
-            <h2 id="strength"></h2>
-            <blockquote id="encouragement"></blockquote>
+                            <label for="style">Art style</label>
+                            <select id="style" name="style">
+                                <option value="surprise">Surprise me</option>
+                                <option value="watercolor">Watercolor Storybook</option>
+                                <option value="paper_cut">Layered Paper Cut</option>
+                                <option value="moonlit_gouache">Moonlit Gouache</option>
+                                <option value="botanical_ink">Botanical Ink Wash</option>
+                            </select>
 
-            <section class="carried-question">
-              <p class="section-label">A question to carry</p>
-              <p id="reflection"></p>
+                            <div class="step-actions split-actions">
+                                <button class="text-button step-back" type="button">Back</button>
+                                <button class="primary-button grow-button" id="grow-button" type="submit">
+                                    <span>Grow my forest</span>
+                                    <svg viewBox="0 0 32 20" aria-hidden="true">
+                                        <path d="M2 10h24M19 3l8 7-8 7M13 8c-4-5-8-4-9-2 4 1 7 3 9 6" />
+                                    </svg>
+                                </button>
+                            </div>
+                        </section>
+                    </form>
+
+                    <div
+                        class="status-region"
+                        id="status-region"
+                        role="status"
+                        aria-live="polite"
+                        aria-atomic="true"
+                    ></div>
+                </div>
+
+                <figure class="entry-art">
+                    <img src="/assets/fox-path.png" alt="" />
+                </figure>
             </section>
 
-            <section class="spell-section">
-              <p class="section-label">Tiny spell</p>
-              <p class="spell" id="spell"></p>
-              <button class="copy-button" id="copy-spell" type="button">
-                <svg viewBox="0 0 24 24" aria-hidden="true">
-                  <rect x="8" y="8" width="11" height="12" rx="1" />
-                  <path d="M16 8V4H5v12h3" />
-                </svg>
-                <span>Copy spell</span>
-              </button>
+            <section class="view experience-view" hidden id="experience-view">
+                <div class="path-header">
+                    <h1 id="forest-title">A path is growing</h1>
+                    <p id="clearing-progress">Clearing 1</p>
+                    <p
+                        class="art-style-label"
+                        id="art-style-label"
+                        aria-live="polite"
+                    ></p>
+                    <div
+                        class="progress-dots"
+                        id="progress-dots"
+                        aria-hidden="true"
+                    ></div>
+                </div>
+
+                <section
+                    class="soundscape-player"
+                    id="soundscape-player"
+                    aria-live="polite"
+                    hidden
+                >
+                    <div>
+                        <p class="section-label">Forest soundscape</p>
+                        <p class="soundscape-note">
+                            A generated instrumental companion. Press play when
+                            ready.
+                        </p>
+                    </div>
+                    <audio
+                        id="soundscape-audio"
+                        controls
+                        loop
+                        preload="metadata"
+                    ></audio>
+                </section>
+
+                <article class="clearing">
+                    <figure class="clearing-art">
+                        <div class="image-wash" aria-hidden="true"></div>
+                        <img id="clearing-image" src="" alt="" />
+                    </figure>
+
+                    <div class="clearing-copy">
+                        <p class="scene-title" id="scene-title"></p>
+                        <p class="scene-intro" id="scene-intro"></p>
+                        <div class="narration" id="narration"></div>
+
+                        <section class="carried-question">
+                            <p class="section-label">A question to carry</p>
+                            <p id="reflection"></p>
+                        </section>
+
+                        <section class="spell-section">
+                            <p class="section-label">Tiny spell</p>
+                            <p class="spell" id="spell"></p>
+                            <button
+                                class="copy-button"
+                                id="copy-spell"
+                                type="button"
+                            >
+                                <svg viewBox="0 0 24 24" aria-hidden="true">
+                                    <rect
+                                        x="8"
+                                        y="8"
+                                        width="11"
+                                        height="12"
+                                        rx="1"
+                                    />
+                                    <path d="M16 8V4H5v12h3" />
+                                </svg>
+                                <span>Copy spell</span>
+                            </button>
+                        </section>
+
+                        <div class="path-actions">
+                            <button
+                                class="primary-button"
+                                id="walk-on"
+                                type="button"
+                            >
+                                <span>Walk on</span>
+                                <svg viewBox="0 0 32 20" aria-hidden="true">
+                                    <path
+                                        d="M2 10h24M19 3l8 7-8 7M13 8c-4-5-8-4-9-2 4 1 7 3 9 6"
+                                    />
+                                </svg>
+                            </button>
+                            <button
+                                class="primary-button save-button"
+                                id="save-forest"
+                                type="button"
+                                hidden
+                            >
+                                <span>Save your forest</span>
+                                <svg viewBox="0 0 24 24" aria-hidden="true">
+                                    <path
+                                        d="M12 3v12m0 0 5-5m-5 5-5-5M5 20h14"
+                                    />
+                                </svg>
+                            </button>
+                            <button
+                                class="text-button"
+                                id="start-over"
+                                type="button"
+                            >
+                                Start another path
+                            </button>
+                        </div>
+                    </div>
+                </article>
             </section>
+        </main>
 
-            <div class="path-actions">
-              <button class="primary-button" id="walk-on" type="button">
-                <span>Walk on</span>
-                <svg viewBox="0 0 32 20" aria-hidden="true">
-                  <path d="M2 10h24M19 3l8 7-8 7M13 8c-4-5-8-4-9-2 4 1 7 3 9 6" />
-                </svg>
-              </button>
-              <button class="primary-button save-button" id="save-forest" type="button" hidden>
-                <span>Save your forest</span>
-                <svg viewBox="0 0 24 24" aria-hidden="true">
-                  <path d="M12 3v12m0 0 5-5m-5 5-5-5M5 20h14" />
-                </svg>
-              </button>
-              <button class="text-button" id="start-over" type="button">Start another path</button>
-            </div>
-          </div>
-        </article>
-      </section>
-    </main>
-
-    <footer>Whimsical encouragement, not a substitute for professional support.</footer>
-    <script src="/app.js" defer></script>
-  </body>
+        <footer>
+            Whimsical encouragement, not a substitute for professional support.
+        </footer>
+        <script src="/app.js" defer></script>
+    </body>
 </html>

frontend/styles.css

@@ -1,866 +1,1204 @@
 :root {
-  --paper: #f5f0df;
-  --paper-light: #fbf8ed;
-  --ink: #243c31;
-  --ink-soft: #4c574f;
-  --moss: #53683d;
-  --moss-dark: #3f5634;
-  --sage: #8fa184;
-  --sage-light: #c8cfb7;
-  --rose: #c98f83;
-  --honey: #e4b75e;
-  --line: rgba(82, 104, 61, 0.48);
-  --serif: "Iowan Old Style", "Palatino Linotype", "Book Antiqua", Baskerville, Georgia, serif;
-  --sans: "Avenir Next", Avenir, "Segoe UI", Helvetica, Arial, sans-serif;
+    --paper: #f5f0df;
+    --paper-light: #fbf8ed;
+    --ink: #243c31;
+    --ink-soft: #4c574f;
+    --moss: #53683d;
+    --moss-dark: #3f5634;
+    --sage: #8fa184;
+    --sage-light: #c8cfb7;
+    --rose: #c98f83;
+    --honey: #e4b75e;
+    --line: rgba(82, 104, 61, 0.48);
+    --serif:
+        "Iowan Old Style", "Palatino Linotype", "Book Antiqua", Baskerville,
+        Georgia, serif;
+    --sans: "Avenir Next", Avenir, "Segoe UI", Helvetica, Arial, sans-serif;
 }
 
 * {
-  box-sizing: border-box;
+    box-sizing: border-box;
 }
 
 html {
-  min-width: 320px;
-  min-height: 100%;
-  background: var(--paper);
+    min-width: 320px;
+    min-height: 100%;
+    background: var(--paper);
 }
 
 body {
-  min-height: 100vh;
-  margin: 0;
-  overflow-x: hidden;
-  color: var(--ink);
-  background:
-    radial-gradient(circle at 22% 18%, rgba(255, 255, 255, 0.58), transparent 35%),
-    radial-gradient(circle at 83% 71%, rgba(207, 213, 186, 0.18), transparent 32%),
-    var(--paper);
-  font-family: var(--sans);
-  text-rendering: optimizeLegibility;
+    min-height: 100vh;
+    margin: 0;
+    overflow-x: hidden;
+    color: var(--ink);
+    background:
+        radial-gradient(
+            circle at 22% 18%,
+            rgba(255, 255, 255, 0.58),
+            transparent 35%
+        ),
+        radial-gradient(
+            circle at 83% 71%,
+            rgba(207, 213, 186, 0.18),
+            transparent 32%
+        ),
+        var(--paper);
+    font-family: var(--sans);
+    text-rendering: optimizeLegibility;
 }
 
 button,
 input,
+select,
 textarea {
-  font: inherit;
+    font: inherit;
 }
 
 button {
-  color: inherit;
+    color: inherit;
 }
 
 .paper-grain {
-  position: fixed;
-  z-index: -1;
-  inset: 0;
-  pointer-events: none;
-  opacity: 0.28;
-  background-image: url("/assets/paper-texture.svg");
+    position: fixed;
+    z-index: -1;
+    inset: 0;
+    pointer-events: none;
+    opacity: 0.28;
+    background-image: url("/assets/paper-texture.svg");
 }
 
 .site-header {
-  display: flex;
-  align-items: center;
-  width: min(100% - 64px, 1380px);
-  height: 104px;
-  margin: 0 auto;
+    display: flex;
+    align-items: center;
+    width: min(calc(100% - 64px), 1380px);
+    height: 104px;
+    margin: 0 auto;
 }
 
 .brand {
-  display: inline-flex;
-  align-items: center;
-  gap: 16px;
-  padding: 0;
-  border: 0;
-  background: transparent;
-  font-family: var(--serif);
-  font-size: 1.42rem;
-  cursor: pointer;
+    display: inline-flex;
+    align-items: center;
+    gap: 16px;
+    padding: 0;
+    border: 0;
+    background: transparent;
+    font-family: var(--serif);
+    font-size: 1.42rem;
+    cursor: pointer;
 }
 
 .brand-mark {
-  width: 54px;
-  height: 54px;
-  overflow: visible;
-  fill: none;
-  stroke: #6f825b;
-  stroke-width: 1.7;
-  stroke-linecap: round;
-  stroke-linejoin: round;
+    width: 54px;
+    height: 54px;
+    overflow: visible;
+    fill: none;
+    stroke: #6f825b;
+    stroke-width: 1.7;
+    stroke-linecap: round;
+    stroke-linejoin: round;
 }
 
 .brand-mark ellipse {
-  fill: rgba(111, 130, 91, 0.5);
-  stroke-width: 1;
+    fill: rgba(111, 130, 91, 0.5);
+    stroke-width: 1;
 }
 
 .view {
-  width: min(100% - 64px, 1380px);
-  margin: 0 auto;
+    width: min(calc(100% - 64px), 1380px);
+    margin: 0 auto;
 }
 
 .entry-view {
-  display: grid;
-  grid-template-columns: minmax(420px, 0.88fr) minmax(520px, 1.2fr);
-  align-items: center;
-  min-height: calc(100vh - 174px);
+    display: grid;
+    grid-template-columns: minmax(420px, 0.88fr) minmax(520px, 1.2fr);
+    align-items: center;
+    min-height: calc(100vh - 174px);
 }
 
 .entry-copy {
-  z-index: 2;
-  max-width: 570px;
-  padding: 38px 0 72px 34px;
+    z-index: 2;
+    max-width: 570px;
+    padding: 38px 0 72px 34px;
 }
 
 .entry-copy h1,
 .path-header h1 {
-  margin: 0;
-  color: var(--ink);
-  font-family: var(--serif);
-  font-weight: 400;
-  letter-spacing: -0.045em;
+    margin: 0;
+    color: var(--ink);
+    font-family: var(--serif);
+    font-weight: 400;
+    letter-spacing: -0.045em;
 }
 
 .entry-copy h1 {
-  font-size: clamp(4.2rem, 7vw, 7.25rem);
-  line-height: 0.82;
+    font-size: clamp(4.2rem, 7vw, 7.25rem);
+    line-height: 0.82;
 }
 
 .intro {
-  max-width: 540px;
-  margin: 34px 0 42px;
-  color: var(--ink-soft);
-  font-size: clamp(1.25rem, 1.7vw, 1.7rem);
-  line-height: 1.48;
+    max-width: 540px;
+    margin: 34px 0 42px;
+    color: var(--ink-soft);
+    font-size: clamp(1.25rem, 1.7vw, 1.7rem);
+    line-height: 1.48;
 }
 
 #forest-form {
-  display: grid;
-  gap: 10px;
+    display: grid;
+    gap: 10px;
+}
+
+.eyebrow,
+.step-kicker {
+    margin: 0 0 12px;
+    color: var(--moss-dark);
+    font-size: 0.84rem;
+    font-weight: 700;
+    letter-spacing: 0.12em;
+    text-transform: uppercase;
+}
+
+.step-tracker {
+    display: grid;
+    grid-template-columns: repeat(5, 1fr);
+    gap: 8px;
+    padding: 0;
+    margin: 0 0 24px;
+    list-style: none;
+}
+
+.step-tracker li {
+    position: relative;
+    min-height: 36px;
+    padding: 10px 8px;
+    border: 1px solid rgba(83, 104, 61, 0.2);
+    border-radius: 999px;
+    color: rgba(36, 60, 49, 0.55);
+    background: rgba(251, 248, 237, 0.48);
+    font-size: 0.72rem;
+    font-weight: 700;
+    text-align: center;
+}
+
+.step-tracker li.is-current,
+.step-tracker li.is-complete {
+    border-color: rgba(83, 104, 61, 0.58);
+    color: var(--ink);
+    background: rgba(200, 207, 183, 0.34);
+}
+
+.form-step {
+    display: grid;
+    gap: 12px;
+    animation: stepIn 260ms ease both;
+}
+
+.form-step[hidden] {
+    display: none;
+}
+
+.form-step h2 {
+    margin: 0;
+    font-family: var(--serif);
+    font-size: clamp(2rem, 3.1vw, 3.1rem);
+    font-weight: 400;
+    line-height: 1.04;
+    letter-spacing: -0.035em;
+}
+
+.step-help {
+    margin: 0 0 8px;
+    color: var(--ink-soft);
+    line-height: 1.5;
+}
+
+#forest-form fieldset {
+    min-width: 0;
+    padding: 0;
+    margin: 8px 0 18px;
+    border: 0;
+}
+
+#forest-form legend {
+    margin-bottom: 10px;
+    color: #26382f;
+    font-weight: 700;
 }
 
 #forest-form label {
-  margin-top: 12px;
-  color: #26382f;
-  font-size: 1.02rem;
-  font-weight: 600;
+    margin-top: 12px;
+    color: #26382f;
+    font-size: 1.02rem;
+    font-weight: 600;
 }
 
 #forest-form input,
+#forest-form select,
 #forest-form textarea {
-  width: 100%;
-  border: 1.5px solid rgba(48, 78, 62, 0.8);
-  border-radius: 5px;
-  outline: 0;
-  color: var(--ink);
-  background: rgba(251, 248, 237, 0.58);
-  box-shadow: inset 0 0 22px rgba(255, 255, 255, 0.35);
-  font-size: 1.14rem;
-  transition:
-    border-color 180ms ease,
-    box-shadow 180ms ease,
-    background 180ms ease;
+    width: 100%;
+    border: 1.5px solid rgba(48, 78, 62, 0.8);
+    border-radius: 5px;
+    outline: 0;
+    color: var(--ink);
+    background: rgba(251, 248, 237, 0.58);
+    box-shadow: inset 0 0 22px rgba(255, 255, 255, 0.35);
+    font-size: 1.14rem;
+    transition:
+        border-color 180ms ease,
+        box-shadow 180ms ease,
+        background 180ms ease;
 }
 
 #forest-form input {
-  height: 58px;
-  padding: 0 18px;
+    height: 58px;
+    padding: 0 18px;
+}
+
+#forest-form select {
+    height: 58px;
+    padding: 0 48px 0 18px;
+    appearance: none;
+    background-image:
+        linear-gradient(45deg, transparent 50%, var(--moss) 50%),
+        linear-gradient(135deg, var(--moss) 50%, transparent 50%);
+    background-position:
+        calc(100% - 23px) 25px,
+        calc(100% - 17px) 25px;
+    background-repeat: no-repeat;
+    background-size: 6px 6px;
 }
 
 #forest-form textarea {
-  min-height: 128px;
-  padding: 16px 18px;
-  line-height: 1.45;
-  resize: vertical;
+    min-height: 128px;
+    padding: 16px 18px;
+    line-height: 1.45;
+    resize: vertical;
 }
 
 #forest-form input::placeholder,
 #forest-form textarea::placeholder {
-  color: rgba(68, 78, 72, 0.55);
+    color: rgba(68, 78, 72, 0.55);
 }
 
 #forest-form input:focus,
+#forest-form select:focus,
 #forest-form textarea:focus {
-  border-color: var(--moss);
-  background: rgba(255, 253, 245, 0.88);
-  box-shadow: 0 0 0 4px rgba(83, 104, 61, 0.14);
+    border-color: var(--moss);
+    background: rgba(255, 253, 245, 0.88);
+    box-shadow: 0 0 0 4px rgba(83, 104, 61, 0.14);
 }
 
 .primary-button {
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  gap: 16px;
-  min-height: 58px;
-  padding: 14px 30px;
-  border: 1px solid rgba(47, 67, 39, 0.72);
-  border-radius: 5px;
-  color: #fffdf3;
-  background: var(--moss);
-  box-shadow: 0 7px 22px rgba(63, 86, 52, 0.12);
-  font-family: var(--serif);
-  font-size: 1.45rem;
-  cursor: pointer;
-  transition:
-    transform 160ms ease,
-    background 160ms ease,
-    box-shadow 160ms ease;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: 16px;
+    min-height: 58px;
+    padding: 14px 30px;
+    border: 1px solid rgba(47, 67, 39, 0.72);
+    border-radius: 5px;
+    color: #fffdf3;
+    background: var(--moss);
+    box-shadow: 0 7px 22px rgba(63, 86, 52, 0.12);
+    font-family: var(--serif);
+    font-size: 1.45rem;
+    cursor: pointer;
+    transition:
+        transform 160ms ease,
+        background 160ms ease,
+        box-shadow 160ms ease;
 }
 
 .primary-button svg {
-  width: 30px;
-  height: 20px;
-  fill: none;
-  stroke: currentColor;
-  stroke-width: 1.7;
-  stroke-linecap: round;
-  stroke-linejoin: round;
+    width: 30px;
+    height: 20px;
+    fill: none;
+    stroke: currentColor;
+    stroke-width: 1.7;
+    stroke-linecap: round;
+    stroke-linejoin: round;
 }
 
 .primary-button:hover:not(:disabled) {
-  transform: translateY(-2px);
-  background: var(--moss-dark);
-  box-shadow: 0 11px 28px rgba(63, 86, 52, 0.2);
+    transform: translateY(-2px);
+    background: var(--moss-dark);
+    box-shadow: 0 11px 28px rgba(63, 86, 52, 0.2);
 }
 
 .primary-button:disabled {
-  cursor: wait;
-  opacity: 0.62;
+    cursor: wait;
+    opacity: 0.62;
 }
 
 .grow-button {
-  width: 100%;
-  margin-top: 20px;
-  min-height: 68px;
-  font-size: 1.82rem;
+    width: 100%;
+    margin-top: 20px;
+    min-height: 68px;
+    font-size: 1.82rem;
+}
+
+.step-actions {
+    display: flex;
+    justify-content: flex-end;
+    gap: 16px;
+    margin-top: 18px;
+}
+
+.split-actions {
+    justify-content: space-between;
+}
+
+.split-actions .grow-button {
+    width: auto;
+    min-width: min(100%, 280px);
+    margin-top: 0;
+}
+
+.choice-grid {
+    display: grid;
+    gap: 12px;
+}
+
+.choice-grid.two-column {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+}
+
+.choice-grid.three-column {
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+}
+
+.choice-card {
+    position: relative;
+    display: grid;
+    gap: 5px;
+    min-height: 104px;
+    padding: 16px 16px 16px 46px;
+    margin: 0;
+    border: 1.5px solid rgba(48, 78, 62, 0.34);
+    border-radius: 14px;
+    background: rgba(251, 248, 237, 0.56);
+    box-shadow: inset 0 0 24px rgba(255, 255, 255, 0.22);
+    cursor: pointer;
+    transition:
+        transform 160ms ease,
+        border-color 160ms ease,
+        background 160ms ease,
+        box-shadow 160ms ease;
+}
+
+.choice-card.compact {
+    min-height: 66px;
+    align-content: center;
+}
+
+#forest-form .choice-card input {
+    position: absolute;
+    top: 18px;
+    left: 17px;
+    width: 17px;
+    height: 17px;
+    padding: 0;
+    border: 0;
+    border-radius: 50%;
+    background: transparent;
+    box-shadow: none;
+    accent-color: var(--moss);
+}
+
+.choice-card span {
+    color: var(--ink);
+    font-family: var(--serif);
+    font-size: 1.18rem;
+    font-weight: 400;
+    line-height: 1.12;
+}
+
+.choice-card small {
+    color: var(--ink-soft);
+    font-size: 0.82rem;
+    font-weight: 500;
+    line-height: 1.35;
+}
+
+.choice-card:has(input:checked) {
+    border-color: rgba(63, 86, 52, 0.88);
+    background: rgba(200, 207, 183, 0.3);
+    box-shadow: 0 8px 22px rgba(63, 86, 52, 0.1);
+}
+
+.choice-card:hover {
+    transform: translateY(-1px);
+    border-color: rgba(63, 86, 52, 0.62);
 }
 
 .status-region {
-  min-height: 28px;
-  margin-top: 18px;
-  color: var(--moss-dark);
-  font-size: 0.98rem;
-  line-height: 1.5;
+    min-height: 28px;
+    margin-top: 18px;
+    color: var(--moss-dark);
+    font-size: 0.98rem;
+    line-height: 1.5;
 }
 
 .status-region:not(:empty)::before {
-  display: inline-block;
-  width: 7px;
-  height: 7px;
-  margin: 0 10px 1px 2px;
-  border-radius: 50%;
-  background: var(--honey);
-  box-shadow: 0 0 10px rgba(228, 183, 94, 0.75);
-  content: "";
-  animation: breathe 1.7s ease-in-out infinite;
+    display: inline-block;
+    width: 7px;
+    height: 7px;
+    margin: 0 10px 1px 2px;
+    border-radius: 50%;
+    background: var(--honey);
+    box-shadow: 0 0 10px rgba(228, 183, 94, 0.75);
+    content: "";
+    animation: breathe 1.7s ease-in-out infinite;
 }
 
 .status-region.is-error {
-  max-width: 570px;
-  padding: 14px 16px;
-  border-left: 3px solid var(--rose);
-  color: #5e3934;
-  background: rgba(201, 143, 131, 0.12);
+    max-width: 570px;
+    padding: 14px 16px;
+    border-left: 3px solid var(--rose);
+    color: #5e3934;
+    background: rgba(201, 143, 131, 0.12);
 }
 
 .entry-art {
-  position: relative;
-  align-self: stretch;
-  min-height: 680px;
-  margin: -78px -120px -10px -100px;
-  overflow: hidden;
+    position: relative;
+    align-self: stretch;
+    min-height: 680px;
+    margin: -78px -120px -10px -100px;
+    overflow: hidden;
 }
 
 .entry-art::after {
-  position: absolute;
-  inset: 0;
-  pointer-events: none;
-  background:
-    linear-gradient(90deg, var(--paper) 0%, transparent 22%),
-    linear-gradient(0deg, var(--paper) 0%, transparent 12%);
-  content: "";
+    position: absolute;
+    inset: 0;
+    pointer-events: none;
+    background:
+        linear-gradient(90deg, var(--paper) 0%, transparent 22%),
+        linear-gradient(0deg, var(--paper) 0%, transparent 12%);
+    content: "";
 }
 
 .entry-art img {
-  width: 100%;
-  height: 100%;
-  object-fit: cover;
-  object-position: 56% 50%;
-  mix-blend-mode: multiply;
+    width: 100%;
+    height: 100%;
+    object-fit: cover;
+    object-position: 56% 50%;
+    mix-blend-mode: multiply;
 }
 
 .experience-view {
-  min-height: calc(100vh - 174px);
-  padding: 0 24px 48px;
+    min-height: calc(100vh - 174px);
+    padding: 0 24px 48px;
 }
 
 .path-header {
-  max-width: 980px;
-  margin: -14px auto 36px;
-  text-align: center;
+    max-width: 980px;
+    margin: -14px auto 36px;
+    text-align: center;
 }
 
 .path-header h1 {
-  font-size: clamp(3rem, 5vw, 5.3rem);
-  line-height: 1.05;
+    font-size: clamp(3rem, 5vw, 5.3rem);
+    line-height: 1.05;
 }
 
 #clearing-progress {
-  margin: 18px 0 10px;
-  color: var(--ink-soft);
-  font-size: 1rem;
-  letter-spacing: 0.08em;
+    margin: 18px 0 4px;
+    color: var(--ink-soft);
+    font-size: 1rem;
+    letter-spacing: 0.08em;
+}
+
+.art-style-label {
+    min-height: 20px;
+    margin: 0 0 10px;
+    color: var(--moss-dark);
+    font-family: var(--serif);
+    font-size: 1rem;
 }
 
 .progress-dots {
-  display: flex;
-  justify-content: center;
-  gap: 18px;
-  min-height: 18px;
+    display: flex;
+    justify-content: center;
+    gap: 18px;
+    min-height: 18px;
 }
 
 .progress-dot {
-  width: 14px;
-  height: 14px;
-  border-radius: 50%;
-  background: rgba(143, 161, 132, 0.24);
-  transition:
-    transform 180ms ease,
-    background 180ms ease;
+    width: 14px;
+    height: 14px;
+    border-radius: 50%;
+    background: rgba(143, 161, 132, 0.24);
+    transition:
+        transform 180ms ease,
+        background 180ms ease;
 }
 
 .progress-dot.is-complete {
-  background: rgba(143, 161, 132, 0.7);
+    background: rgba(143, 161, 132, 0.7);
 }
 
 .progress-dot.is-current {
-  transform: scale(1.1);
-  background: var(--moss-dark);
+    transform: scale(1.1);
+    background: var(--moss-dark);
+}
+
+.soundscape-player {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 28px;
+    width: min(100%, 900px);
+    margin: -12px auto 30px;
+    padding: 16px 20px;
+    border: 1px solid rgba(83, 104, 61, 0.3);
+    border-radius: 8px;
+    background: rgba(251, 248, 237, 0.58);
+    box-shadow: 0 8px 30px rgba(63, 86, 52, 0.06);
+}
+
+.soundscape-note {
+    margin: 5px 0 0;
+    color: var(--ink-soft);
+    font-family: var(--serif);
+    font-size: 1rem;
+}
+
+.soundscape-player audio {
+    width: min(420px, 48vw);
+    height: 42px;
+    accent-color: var(--moss);
 }
 
 .clearing {
-  display: grid;
-  grid-template-columns: minmax(460px, 1.05fr) minmax(430px, 0.95fr);
-  gap: clamp(52px, 7vw, 118px);
-  align-items: center;
-  width: min(100%, 1240px);
-  margin: 0 auto;
+    display: grid;
+    grid-template-columns: minmax(460px, 1.05fr) minmax(430px, 0.95fr);
+    gap: clamp(52px, 7vw, 118px);
+    align-items: center;
+    width: min(100%, 1240px);
+    margin: 0 auto;
 }
 
 .clearing-art {
-  position: relative;
-  min-height: 610px;
-  margin: 0;
+    position: relative;
+    min-height: 610px;
+    margin: 0;
 }
 
 .image-wash {
-  position: absolute;
-  inset: 10% 2% 2%;
-  border-radius: 48% 52% 55% 45%;
-  background:
-    radial-gradient(circle at 43% 45%, rgba(182, 197, 190, 0.45), transparent 43%),
-    radial-gradient(circle at 48% 76%, rgba(121, 141, 100, 0.2), transparent 45%);
-  filter: blur(13px);
+    position: absolute;
+    inset: 10% 2% 2%;
+    border-radius: 48% 52% 55% 45%;
+    background:
+        radial-gradient(
+            circle at 43% 45%,
+            rgba(182, 197, 190, 0.45),
+            transparent 43%
+        ),
+        radial-gradient(
+            circle at 48% 76%,
+            rgba(121, 141, 100, 0.2),
+            transparent 45%
+        );
+    filter: blur(13px);
 }
 
 .clearing-art img {
-  position: absolute;
-  z-index: 1;
-  inset: 0;
-  width: 100%;
-  height: 100%;
-  border-radius: 44% 48% 45% 50%;
-  object-fit: cover;
-  mix-blend-mode: multiply;
-  mask-image: radial-gradient(ellipse 66% 76% at center, black 54%, transparent 100%);
+    position: absolute;
+    z-index: 1;
+    inset: 0;
+    width: 100%;
+    height: 100%;
+    border-radius: 44% 48% 45% 50%;
+    object-fit: cover;
+    mix-blend-mode: multiply;
+    mask-image: radial-gradient(
+        ellipse 66% 76% at center,
+        black 54%,
+        transparent 100%
+    );
 }
 
 .clearing-copy {
-  max-width: 570px;
-  padding: 18px 0 32px;
+    max-width: 570px;
+    padding: 18px 0 32px;
 }
 
-.creature,
 .section-label {
-  margin: 0;
-  color: var(--moss-dark);
-  font-size: 0.79rem;
-  font-weight: 650;
-  letter-spacing: 0.2em;
-  text-transform: uppercase;
+    margin: 0;
+    color: var(--moss-dark);
+    font-size: 0.79rem;
+    font-weight: 650;
+    letter-spacing: 0.2em;
+    text-transform: uppercase;
+}
+
+.scene-title {
+    font: 600 14px "Avenir Next", Arial, sans-serif;
+    letter-spacing: 0.16em;
+    text-transform: uppercase;
+    color: #3f5634;
+    margin: 0 0 6px;
+}
+
+.scene-intro {
+    font: italic 19px/1.5 "Iowan Old Style", Georgia, serif;
+    color: #4c574f;
+    margin: 0 0 18px;
 }
 
-#strength {
-  margin: 10px 0 20px;
-  font-family: var(--serif);
-  font-size: clamp(2rem, 3vw, 3.15rem);
-  font-weight: 400;
-  line-height: 1.1;
+.narration {
+    font: 21px/1.7 "Iowan Old Style", Georgia, serif;
+    color: #243c31;
+    margin: 0 0 28px;
 }
 
-#encouragement {
-  margin: 0 0 34px;
-  font-family: var(--serif);
-  font-size: clamp(1.78rem, 2.8vw, 2.75rem);
-  font-weight: 400;
-  line-height: 1.23;
+.narration p {
+    margin: 0 0 14px;
+}
+
+.narration p:last-child {
+    margin-bottom: 0;
 }
 
 .carried-question,
 .spell-section {
-  padding: 26px 2px;
-  border-top: 2px solid var(--line);
+    padding: 26px 2px;
+    border-top: 2px solid var(--line);
 }
 
 #reflection,
 .spell {
-  margin: 10px 0 0;
-  font-family: var(--serif);
-  font-size: clamp(1.35rem, 2.1vw, 2rem);
-  line-height: 1.28;
+    margin: 10px 0 0;
+    font-family: var(--serif);
+    font-size: clamp(1.35rem, 2.1vw, 2rem);
+    line-height: 1.28;
 }
 
 .spell-section {
-  padding-bottom: 20px;
+    padding-bottom: 20px;
 }
 
 .spell {
-  margin-bottom: 14px;
+    margin-bottom: 14px;
 }
 
 .copy-button {
-  display: inline-flex;
-  align-items: center;
-  gap: 9px;
-  min-height: 42px;
-  padding: 8px 17px;
-  border: 1.4px solid var(--moss-dark);
-  border-radius: 5px;
-  background: rgba(251, 248, 237, 0.55);
-  cursor: pointer;
+    display: inline-flex;
+    align-items: center;
+    gap: 9px;
+    min-height: 42px;
+    padding: 8px 17px;
+    border: 1.4px solid var(--moss-dark);
+    border-radius: 5px;
+    background: rgba(251, 248, 237, 0.55);
+    cursor: pointer;
 }
 
 .copy-button svg {
-  width: 20px;
-  height: 20px;
-  fill: none;
-  stroke: currentColor;
-  stroke-width: 1.6;
+    width: 20px;
+    height: 20px;
+    fill: none;
+    stroke: currentColor;
+    stroke-width: 1.6;
 }
 
 .path-actions {
-  display: grid;
-  gap: 10px;
-  margin-top: 18px;
+    display: grid;
+    gap: 10px;
+    margin-top: 18px;
 }
 
 .save-button {
-  background: #6b7048;
+    background: #6b7048;
 }
 
 .text-button {
-  justify-self: center;
-  padding: 10px 18px;
-  border: 0;
-  color: var(--moss-dark);
-  background: transparent;
-  font-size: 1.02rem;
-  cursor: pointer;
+    justify-self: center;
+    padding: 10px 18px;
+    border: 0;
+    color: var(--moss-dark);
+    background: transparent;
+    font-size: 1.02rem;
+    cursor: pointer;
 }
 
 .text-button:hover {
-  text-decoration: underline;
-  text-underline-offset: 4px;
+    text-decoration: underline;
+    text-underline-offset: 4px;
 }
 
 footer {
-  width: min(100% - 40px, 1380px);
-  margin: 0 auto;
-  padding: 16px 0 24px;
-  color: rgba(54, 65, 58, 0.78);
-  font-size: 0.78rem;
-  text-align: center;
+    width: min(100% - 40px, 1380px);
+    margin: 0 auto;
+    padding: 16px 0 24px;
+    color: rgba(54, 65, 58, 0.78);
+    font-size: 0.78rem;
+    text-align: center;
 }
 
 .fireflies {
-  position: fixed;
-  z-index: 4;
-  inset: 0;
-  pointer-events: none;
+    position: fixed;
+    z-index: 4;
+    inset: 0;
+    pointer-events: none;
 }
 
 .fireflies i {
-  position: absolute;
-  width: 5px;
-  height: 5px;
-  border-radius: 50%;
-  background: rgba(244, 199, 92, 0.8);
-  box-shadow: 0 0 12px rgba(244, 199, 92, 0.85);
-  animation: drift 8s ease-in-out infinite;
+    position: absolute;
+    width: 5px;
+    height: 5px;
+    border-radius: 50%;
+    background: rgba(244, 199, 92, 0.8);
+    box-shadow: 0 0 12px rgba(244, 199, 92, 0.85);
+    animation: drift 8s ease-in-out infinite;
 }
 
 .fireflies i:nth-child(1) {
-  top: 31%;
-  left: 78%;
+    top: 31%;
+    left: 78%;
 }
 
 .fireflies i:nth-child(2) {
-  top: 65%;
-  left: 69%;
-  animation-delay: -2s;
+    top: 65%;
+    left: 69%;
+    animation-delay: -2s;
 }
 
 .fireflies i:nth-child(3) {
-  top: 43%;
-  left: 91%;
-  animation-delay: -4s;
+    top: 43%;
+    left: 91%;
+    animation-delay: -4s;
 }
 
 .fireflies i:nth-child(4) {
-  top: 76%;
-  left: 85%;
-  animation-delay: -6s;
+    top: 76%;
+    left: 85%;
+    animation-delay: -6s;
 }
 
 .fireflies i:nth-child(5) {
-  top: 56%;
-  left: 53%;
-  animation-delay: -3s;
+    top: 56%;
+    left: 53%;
+    animation-delay: -3s;
 }
 
 [hidden] {
-  display: none !important;
+    display: none !important;
 }
 
 button:focus-visible,
 input:focus-visible,
+select:focus-visible,
 textarea:focus-visible {
-  outline: 3px solid rgba(228, 183, 94, 0.72);
-  outline-offset: 4px;
+    outline: 3px solid rgba(228, 183, 94, 0.72);
+    outline-offset: 4px;
 }
 
 @keyframes drift {
-  0%,
-  100% {
-    opacity: 0.35;
-    transform: translate(0, 0);
-  }
+    0%,
+    100% {
+        opacity: 0.35;
+        transform: translate(0, 0);
+    }
 
-  45% {
-    opacity: 1;
-    transform: translate(9px, -14px);
-  }
+    45% {
+        opacity: 1;
+        transform: translate(9px, -14px);
+    }
 }
 
 @keyframes breathe {
-  0%,
-  100% {
-    opacity: 0.45;
-    transform: scale(0.8);
-  }
+    0%,
+    100% {
+        transform: scale(0.84);
+        opacity: 0.62;
+    }
 
-  50% {
-    opacity: 1;
-    transform: scale(1.12);
-  }
+    50% {
+        transform: scale(1.2);
+        opacity: 1;
+    }
 }
 
-@media (max-width: 1040px) {
-  .entry-view {
-    grid-template-columns: minmax(400px, 0.9fr) 1.1fr;
-  }
+@keyframes stepIn {
+    from {
+        transform: translateY(8px);
+        opacity: 0;
+    }
 
-  .entry-art {
-    margin-left: -150px;
-  }
-
-  .clearing {
-    gap: 48px;
-  }
+    to {
+        transform: translateY(0);
+        opacity: 1;
+    }
 }
 
-@media (max-height: 820px) and (min-width: 761px) {
-  .site-header {
-    height: 72px;
-  }
-
-  .brand {
-    gap: 11px;
-    font-size: 1.08rem;
-  }
-
-  .brand-mark {
-    width: 40px;
-    height: 40px;
-  }
-
-  .entry-view {
-    min-height: calc(100vh - 112px);
-  }
-
-  .entry-copy {
-    padding-top: 12px;
-    padding-bottom: 18px;
-  }
-
-  .entry-copy h1 {
-    font-size: clamp(3.8rem, 5.8vw, 5rem);
-    line-height: 0.8;
-  }
-
-  .intro {
-    margin: 16px 0 13px;
-    font-size: 1.12rem;
-    line-height: 1.38;
-  }
-
-  #forest-form {
-    gap: 5px;
-  }
-
-  #forest-form label {
-    margin-top: 6px;
-    font-size: 0.87rem;
-  }
-
-  #forest-form input {
-    height: 46px;
-  }
-
-  #forest-form textarea {
-    min-height: 64px;
-    padding-top: 11px;
-    padding-bottom: 11px;
-  }
-
-  .grow-button {
-    min-height: 48px;
-    margin-top: 7px;
-    font-size: 1.35rem;
-  }
-
-  .status-region {
-    min-height: 20px;
-    margin-top: 8px;
-    font-size: 0.85rem;
-  }
-
-  .entry-art {
-    min-height: 570px;
-  }
-
-  .experience-view {
-    min-height: calc(100vh - 112px);
-    padding-bottom: 6px;
-  }
+@media (max-width: 1040px) {
+    .entry-view {
+        grid-template-columns: minmax(400px, 0.9fr) 1.1fr;
+    }
 
-  .path-header {
-    margin: -18px auto 12px;
-  }
+    .entry-art {
+        margin-left: -150px;
+    }
 
-  .path-header h1 {
-    font-size: clamp(2.8rem, 4.2vw, 3.5rem);
-  }
+    .clearing {
+        gap: 48px;
+    }
+}
 
-  #clearing-progress {
-    margin: 8px 0 6px;
-    font-size: 0.82rem;
-  }
-
-  .progress-dots {
-    gap: 14px;
-    min-height: 12px;
-  }
-
-  .progress-dot {
-    width: 11px;
-    height: 11px;
-  }
-
-  .clearing {
-    grid-template-columns: minmax(390px, 0.9fr) minmax(520px, 1.1fr);
-    gap: 42px;
-  }
-
-  .clearing-art {
-    min-height: 475px;
-  }
-
-  .clearing-copy {
-    max-width: 640px;
-    padding: 0 0 8px;
-  }
-
-  #strength {
-    margin: 7px 0 10px;
-    font-size: 2.15rem;
-  }
-
-  #encouragement {
-    margin-bottom: 15px;
-    font-size: 1.78rem;
-    line-height: 1.16;
-  }
-
-  .carried-question,
-  .spell-section {
-    padding: 10px 2px;
-  }
-
-  #reflection,
-  .spell {
-    margin-top: 6px;
-    font-size: 1.2rem;
-  }
-
-  .spell {
-    margin-bottom: 8px;
-  }
-
-  .copy-button {
-    min-height: 36px;
-    padding: 6px 14px;
-  }
-
-  .path-actions {
-    gap: 4px;
-    margin-top: 8px;
-  }
-
-  .path-actions .primary-button {
-    min-height: 45px;
-    padding-top: 8px;
-    padding-bottom: 8px;
-    font-size: 1.25rem;
-  }
-
-  .text-button {
-    padding-top: 5px;
-    padding-bottom: 5px;
-    font-size: 0.9rem;
-  }
-
-  footer {
-    padding-top: 7px;
-    padding-bottom: 9px;
-    font-size: 0.7rem;
-  }
+@media (max-height: 820px) and (min-width: 761px) {
+    .site-header {
+        height: 72px;
+    }
+
+    .brand {
+        gap: 11px;
+        font-size: 1.08rem;
+    }
+
+    .brand-mark {
+        width: 40px;
+        height: 40px;
+    }
+
+    .entry-view {
+        min-height: calc(100vh - 112px);
+    }
+
+    .entry-copy {
+        padding-top: 12px;
+        padding-bottom: 18px;
+    }
+
+    .entry-copy h1 {
+        font-size: clamp(3.8rem, 5.8vw, 5rem);
+        line-height: 0.8;
+    }
+
+    .intro {
+        margin: 16px 0 13px;
+        font-size: 1.12rem;
+        line-height: 1.38;
+    }
+
+    #forest-form {
+        gap: 5px;
+    }
+
+    #forest-form label {
+        margin-top: 6px;
+        font-size: 0.87rem;
+    }
+
+    #forest-form input {
+        height: 46px;
+    }
+
+    #forest-form textarea {
+        min-height: 64px;
+        padding-top: 11px;
+        padding-bottom: 11px;
+    }
+
+    .grow-button {
+        min-height: 48px;
+        margin-top: 7px;
+        font-size: 1.35rem;
+    }
+
+    .status-region {
+        min-height: 20px;
+        margin-top: 8px;
+        font-size: 0.85rem;
+    }
+
+    .entry-art {
+        min-height: 570px;
+    }
+
+    .experience-view {
+        min-height: calc(100vh - 112px);
+        padding-bottom: 6px;
+    }
+
+    .path-header {
+        margin: -18px auto 12px;
+    }
+
+    .path-header h1 {
+        font-size: clamp(2.8rem, 4.2vw, 3.5rem);
+    }
+
+    #clearing-progress {
+        margin: 8px 0 6px;
+        font-size: 0.82rem;
+    }
+
+    .art-style-label {
+        margin-bottom: 5px;
+        font-size: 0.88rem;
+    }
+
+    .soundscape-player {
+        margin-bottom: 12px;
+        padding: 9px 14px;
+    }
+
+    .progress-dots {
+        gap: 14px;
+        min-height: 12px;
+    }
+
+    .progress-dot {
+        width: 11px;
+        height: 11px;
+    }
+
+    .clearing {
+        grid-template-columns: minmax(390px, 0.9fr) minmax(520px, 1.1fr);
+        gap: 42px;
+    }
+
+    .clearing-art {
+        min-height: 475px;
+    }
+
+    .clearing-copy {
+        max-width: 640px;
+        padding: 0 0 8px;
+    }
+
+    .scene-title {
+        margin: 7px 0 4px;
+        font-size: 12px;
+    }
+
+    .scene-intro {
+        margin-bottom: 12px;
+        font-size: 16px;
+        line-height: 1.4;
+    }
+
+    .narration {
+        margin-bottom: 15px;
+        font-size: 17px;
+        line-height: 1.55;
+    }
+
+    .carried-question,
+    .spell-section {
+        padding: 10px 2px;
+    }
+
+    #reflection,
+    .spell {
+        margin-top: 6px;
+        font-size: 1.2rem;
+    }
+
+    .spell {
+        margin-bottom: 8px;
+    }
+
+    .copy-button {
+        min-height: 36px;
+        padding: 6px 14px;
+    }
+
+    .path-actions {
+        gap: 4px;
+        margin-top: 8px;
+    }
+
+    .path-actions .primary-button {
+        min-height: 45px;
+        padding-top: 8px;
+        padding-bottom: 8px;
+        font-size: 1.25rem;
+    }
+
+    .text-button {
+        padding-top: 5px;
+        padding-bottom: 5px;
+        font-size: 0.9rem;
+    }
+
+    footer {
+        padding-top: 7px;
+        padding-bottom: 9px;
+        font-size: 0.7rem;
+    }
 }
 
 @media (max-width: 760px) {
-  .site-header {
-    width: min(100% - 36px, 720px);
-    height: 78px;
-  }
-
-  .brand {
-    gap: 10px;
-    font-size: 1.05rem;
-  }
-
-  .brand-mark {
-    width: 38px;
-    height: 38px;
-  }
-
-  .view {
-    width: min(100% - 36px, 720px);
-  }
-
-  .entry-view {
-    display: flex;
-    flex-direction: column;
-    min-height: auto;
-  }
-
-  .entry-copy {
-    width: 100%;
-    max-width: none;
-    padding: 34px 0 24px;
-  }
-
-  .entry-copy h1 {
-    font-size: clamp(3.1rem, 15vw, 4.7rem);
-    letter-spacing: -0.055em;
-  }
-
-  .intro {
-    margin: 28px 0 30px;
-    font-size: 1.2rem;
-  }
-
-  .entry-art {
-    order: -1;
-    align-self: auto;
-    width: calc(100% + 36px);
-    min-height: 310px;
-    margin: -26px -18px -65px;
-    opacity: 0.92;
-  }
-
-  .entry-art::after {
-    background:
-      linear-gradient(0deg, var(--paper) 0%, transparent 42%),
-      linear-gradient(90deg, var(--paper) 0%, transparent 14%);
-  }
-
-  .entry-art img {
-    object-position: 66% 52%;
-  }
-
-  .grow-button {
-    font-size: 1.48rem;
-  }
-
-  .experience-view {
-    padding: 0 0 32px;
-  }
-
-  .path-header {
-    margin: 10px auto 24px;
-  }
-
-  .path-header h1 {
-    font-size: clamp(2.75rem, 13vw, 4.5rem);
-  }
-
-  .clearing {
-    display: block;
-  }
-
-  .clearing-art {
-    min-height: 390px;
-    margin: -6px -10px 4px;
-  }
-
-  .clearing-copy {
-    max-width: none;
-    padding: 8px 0 20px;
-  }
-
-  #encouragement {
-    font-size: clamp(1.9rem, 8vw, 2.55rem);
-  }
-
-  #reflection,
-  .spell {
-    font-size: 1.55rem;
-  }
-
-  footer {
-    padding-bottom: 22px;
-  }
+    .site-header,
+    .view {
+        width: min(calc(100% - 36px), 720px);
+    }
+
+    .step-tracker {
+        grid-template-columns: 1fr;
+    }
+
+    .step-tracker li:not(.is-current) {
+        display: none;
+    }
+
+    .choice-grid.two-column,
+    .choice-grid.three-column {
+        grid-template-columns: 1fr;
+    }
+
+    .step-actions,
+    .split-actions {
+        flex-direction: column-reverse;
+        align-items: stretch;
+    }
+
+    .split-actions .grow-button {
+        width: 100%;
+    }
+
+    .brand {
+        gap: 10px;
+        font-size: 1.05rem;
+    }
+
+    .brand-mark {
+        width: 38px;
+        height: 38px;
+    }
+
+    .view {
+        width: min(calc(100% - 36px), 720px);
+    }
+
+    .entry-view {
+        display: flex;
+        flex-direction: column;
+        min-height: auto;
+    }
+
+    .entry-copy {
+        width: 100%;
+        min-width: 0;
+        max-width: none;
+        padding: 34px 0 24px;
+    }
+
+    .entry-copy h1 {
+        max-width: 100%;
+        font-size: clamp(2.8rem, 11.5vw, 3.5rem);
+        letter-spacing: -0.055em;
+    }
+
+    #forest-form,
+    #forest-form input,
+    #forest-form select,
+    #forest-form textarea {
+        min-width: 0;
+        max-width: 100%;
+    }
+
+    .intro {
+        margin: 28px 0 30px;
+        font-size: 1.2rem;
+    }
+
+    .entry-art {
+        order: -1;
+        align-self: auto;
+        width: calc(100% + 36px);
+        min-height: 310px;
+        margin: -26px -18px -65px;
+        opacity: 0.92;
+    }
+
+    .entry-art::after {
+        background:
+            linear-gradient(0deg, var(--paper) 0%, transparent 42%),
+            linear-gradient(90deg, var(--paper) 0%, transparent 14%);
+    }
+
+    .entry-art img {
+        object-position: 66% 52%;
+    }
+
+    .grow-button {
+        font-size: 1.48rem;
+    }
+
+    .experience-view {
+        padding: 0 0 32px;
+    }
+
+    .path-header {
+        margin: 10px auto 24px;
+    }
+
+    .path-header h1 {
+        font-size: clamp(2.75rem, 13vw, 4.5rem);
+    }
+
+    .soundscape-player {
+        align-items: stretch;
+        flex-direction: column;
+        gap: 12px;
+        margin: -10px auto 24px;
+    }
+
+    .soundscape-player audio {
+        width: 100%;
+    }
+
+    .clearing {
+        display: block;
+    }
+
+    .clearing-art {
+        min-height: 390px;
+        margin: -6px -10px 4px;
+    }
+
+    .clearing-copy {
+        max-width: none;
+        padding: 8px 0 20px;
+    }
+
+    .scene-title {
+        font-size: 13px;
+    }
+
+    .scene-intro {
+        font-size: 17px;
+    }
+
+    .narration {
+        font-size: 19px;
+        line-height: 1.65;
+    }
+
+    #reflection,
+    .spell {
+        font-size: 1.55rem;
+    }
+
+    footer {
+        padding-bottom: 22px;
+    }
 }
 
 @media (prefers-reduced-motion: reduce) {
-  *,
-  *::before,
-  *::after {
-    scroll-behavior: auto !important;
-    animation-duration: 0.01ms !important;
-    animation-iteration-count: 1 !important;
-    transition-duration: 0.01ms !important;
-  }
-
-  .fireflies {
-    display: none;
-  }
+    *,
+    *::before,
+    *::after {
+        scroll-behavior: auto !important;
+        animation-duration: 0.01ms !important;
+        animation-iteration-count: 1 !important;
+        transition-duration: 0.01ms !important;
+    }
+
+    .fireflies {
+        display: none;
+    }
 }

requirements.txt

@@ -1,4 +1,5 @@
 gradio==6.16.0
+huggingface-hub==0.36.2
 httpx==0.28.1
 pillow==12.2.0
 pydantic==2.12.5

src/compliment_forest/backends/image.py

@@ -2,15 +2,94 @@ from __future__ import annotations
 
 import base64
 import hashlib
+import hmac
 import io
 import random
+from collections.abc import Callable
+from dataclasses import dataclass
 from pathlib import Path
-from typing import Protocol
+from typing import Any, Protocol
 
+import httpx
+from huggingface_hub import InferenceClient
 from PIL import Image, ImageDraw, ImageFilter, ImageOps
 
+from compliment_forest.schema import ForestStyle
+
+
+@dataclass(frozen=True)
+class StyleProfile:
+    label: str
+    trigger: str
+    prefix: str
+    suffix: str
+    negative_prompt: str
+
+
+_COMMON_NEGATIVE = (
+    "text, letters, watermark, logo, frame, collage, duplicate animal, extra limbs, "
+    "deformed face, distorted hands, photorealistic stock photo, 3d render"
+)
+
+STYLE_PROFILES: dict[str, StyleProfile] = {
+    "watercolor": StyleProfile(
+        label="Watercolor Storybook",
+        trigger="cmprst_watercolor",
+        prefix=(
+            "cmprst_watercolor, soft watercolor storybook illustration, loose wet-on-wet "
+            "washes, visible cold-press paper grain, feathered edges, "
+        ),
+        suffix=", warm dappled light, muted natural palette, generous negative space",
+        negative_prompt=f"hard outlines, neon, oversaturated, {_COMMON_NEGATIVE}",
+    ),
+    "paper_cut": StyleProfile(
+        label="Layered Paper Cut",
+        trigger="cmprst_papercut",
+        prefix=(
+            "cmprst_papercut, handcrafted layered paper-cut illustration, deckled cut "
+            "edges, overlapping botanical silhouettes, tactile paper fibers, "
+        ),
+        suffix=", soft dimensional shadows, moss and ochre palette, clean composition",
+        negative_prompt=f"paint splashes, glossy plastic, neon, {_COMMON_NEGATIVE}",
+    ),
+    "moonlit_gouache": StyleProfile(
+        label="Moonlit Gouache",
+        trigger="cmprst_moonlit",
+        prefix=(
+            "cmprst_moonlit, moonlit gouache storybook painting, opaque velvety brushwork, "
+            "deep indigo woodland, silver rim light, "
+        ),
+        suffix=", quiet luminous atmosphere, restrained jewel tones, simple composition",
+        negative_prompt=f"daylight, washed-out contrast, digital gradients, {_COMMON_NEGATIVE}",
+    ),
+    "botanical_ink": StyleProfile(
+        label="Botanical Ink Wash",
+        trigger="cmprst_inkwash",
+        prefix=(
+            "cmprst_inkwash, botanical ink-wash illustration, expressive sepia and moss "
+            "brush lines, diluted ink blooms, cream washi paper, "
+        ),
+        suffix=", sparse wildflower details, calm asymmetry, airy negative space",
+        negative_prompt=f"thick cartoon outlines, saturated blocks, neon, {_COMMON_NEGATIVE}",
+    ),
+}
+
+STYLE_LORA_V1_IDS = {
+    "watercolor": "thangvip/compliment-forest-watercolor-flux-lora",
+    "paper_cut": "thangvip/compliment-forest-paper-cut-flux-lora",
+    "moonlit_gouache": "thangvip/compliment-forest-moonlit-gouache-flux-lora",
+    "botanical_ink": "thangvip/compliment-forest-botanical-ink-flux-lora",
+}
+
+STYLE_LORA_IDS = {
+    style: f"{model_id}-v2"
+    for style, model_id in STYLE_LORA_V1_IDS.items()
+}
+STYLE_ADAPTER_WEIGHT = 0.45
+
 STYLE_PREFIX = (
-    "cmprst_forest, soft watercolor storybook illustration, loose wet-on-wet washes, "
+    "cmprst_forest, cmprst_watercolor, soft watercolor storybook illustration, "
+    "loose wet-on-wet washes, "
     "visible cold-press paper grain, no hard outlines, soft feathered edges, "
 )
 STYLE_SUFFIX = (
@@ -23,11 +102,32 @@ NEGATIVE_PROMPT = (
 
 
 class ImageBackend(Protocol):
-    def generate(self, prompt: str, seed: int) -> str: ...
+    def generate(self, prompt: str, seed: int, style: ForestStyle) -> str: ...
+
 
+def resolve_style(style: ForestStyle, seed: int) -> str:
+    if style != "surprise":
+        return style
+    style_ids = tuple(STYLE_PROFILES)
+    return style_ids[seed % len(style_ids)]
 
-def compose_flux_prompt(creature_prompt: str) -> str:
-    return f"{STYLE_PREFIX}{creature_prompt.strip()}{STYLE_SUFFIX}"
+
+def compose_flux_prompt(
+    creature_prompt: str,
+    style: ForestStyle = "watercolor",
+    *,
+    seed: int = 3407,
+) -> str:
+    resolved = resolve_style(style, seed)
+    profile = STYLE_PROFILES[resolved]
+    subject = creature_prompt.strip()
+    style_language = profile.prefix.removeprefix(f"{profile.trigger}, ").rstrip(", ")
+    return (
+        f"{profile.trigger}, primary subject: {subject}. "
+        "Preserve this exact subject, action, and setting as the clear focal point. "
+        "No text, lettering, signature, logo, or watermark anywhere. "
+        f"{style_language}{profile.suffix}"
+    )
 
 
 def image_to_data_uri(image: Image.Image) -> str:
@@ -37,8 +137,31 @@ def image_to_data_uri(image: Image.Image) -> str:
     return f"data:image/png;base64,{encoded}"
 
 
+def clean_generated_image(image: Image.Image) -> Image.Image:
+    """Trim common synthetic signature zones while preserving output dimensions."""
+    width, height = image.size
+    crop = image.crop(
+        (
+            round(width * 0.035),
+            round(height * 0.02),
+            round(width * 0.965),
+            round(height * 0.935),
+        )
+    )
+    return ImageOps.fit(
+        crop,
+        image.size,
+        method=Image.Resampling.LANCZOS,
+    )
+
+
+def sign_modal_request(key: str, prompt: str, seed: int, style: str) -> str:
+    message = f"{prompt}\n{seed}\n{style}".encode()
+    return hmac.new(key.encode(), message, hashlib.sha256).hexdigest()
+
+
 class DemoImageBackend:
-    """Creates stable local artwork for tests and UI development."""
+    """Creates deterministic procedural placeholders for offline development."""
 
     def __init__(
         self,
@@ -48,46 +171,17 @@ class DemoImageBackend:
     ) -> None:
         self.width = width
         self.height = height
-        self.asset_dir = (
-            Path(asset_dir)
-            if asset_dir is not None
-            else Path(__file__).resolve().parents[3] / "frontend" / "assets"
-        )
-
-    def _curated_asset(self, prompt: str, seed: int) -> Image.Image | None:
-        prompt_lower = prompt.casefold()
-        names = {
-            "owl": "owl.png",
-            "snail": "snail.png",
-            "deer": "deer.png",
-            "wren": "wren.png",
-            "fox": "fox-path.png",
-        }
-        filename = next(
-            (asset for keyword, asset in names.items() if keyword in prompt_lower),
-            "fox-path.png",
-        )
-        path = self.asset_dir / filename
-        if not path.exists():
-            return None
-        with Image.open(path) as source:
-            image = ImageOps.fit(
-                source.convert("RGB"),
-                (self.width, self.height),
-                method=Image.Resampling.LANCZOS,
-            )
-        corner = image.getpixel((0, 0))
-        variation = seed % 3
-        image.putpixel((0, 0), tuple(min(255, channel + variation) for channel in corner))
-        return image
-
-    def generate(self, prompt: str, seed: int) -> str:
-        curated = self._curated_asset(prompt, seed)
-        if curated is not None:
-            return image_to_data_uri(curated)
+        self.asset_dir = Path(asset_dir) if asset_dir is not None else None
 
+    def generate(
+        self,
+        prompt: str,
+        seed: int,
+        style: ForestStyle = "surprise",
+    ) -> str:
+        resolved_style = resolve_style(style, seed)
         prompt_seed = int.from_bytes(
-            hashlib.sha256(prompt.encode("utf-8")).digest()[:4],
+            hashlib.sha256(f"{resolved_style}:{prompt}".encode()).digest()[:4],
             byteorder="big",
         )
         rng = random.Random(seed ^ prompt_seed)
@@ -101,6 +195,12 @@ class DemoImageBackend:
             (225, 184, 101, 22),
             (132, 172, 181, 18),
         ]
+        if resolved_style == "moonlit_gouache":
+            palette = [(36, 49, 92, 42), (70, 82, 124, 36), (194, 184, 151, 26)]
+        elif resolved_style == "paper_cut":
+            palette = [(83, 104, 61, 40), (205, 151, 96, 34), (201, 143, 131, 28)]
+        elif resolved_style == "botanical_ink":
+            palette = [(73, 79, 55, 32), (120, 96, 67, 28), (148, 161, 132, 20)]
         for _ in range(100):
             color = rng.choice(palette)
             x = rng.randint(-100, self.width)
@@ -215,13 +315,18 @@ class FluxImageBackend:
         self._pipeline = pipeline
         return pipeline
 
-    def generate(self, prompt: str, seed: int) -> str:
+    def generate(
+        self,
+        prompt: str,
+        seed: int,
+        style: ForestStyle = "watercolor",
+    ) -> str:
         import torch
 
         pipeline = self._load()
         generator = torch.Generator(device="cpu").manual_seed(seed)
         image = pipeline(
-            prompt=compose_flux_prompt(prompt),
+            prompt=compose_flux_prompt(prompt, style, seed=seed),
             negative_prompt=NEGATIVE_PROMPT,
             width=self.width,
             height=self.height,
@@ -229,4 +334,122 @@ class FluxImageBackend:
             guidance_scale=3.5,
             generator=generator,
         ).images[0]
-        return image_to_data_uri(image)
+        return image_to_data_uri(clean_generated_image(image.convert("RGB")))
+
+
+class HfInferenceImageBackend:
+    """Fresh FLUX.1-schnell generation through Hugging Face Inference Providers."""
+
+    def __init__(
+        self,
+        model: str = "black-forest-labs/FLUX.1-schnell",
+        *,
+        client: Any | None = None,
+        provider: str = "auto",
+        width: int = 768,
+        height: int = 768,
+        steps: int = 4,
+        timeout: float = 180,
+    ) -> None:
+        self.model = model
+        self.client = client or InferenceClient(provider=provider, timeout=timeout)
+        self.width = width
+        self.height = height
+        self.steps = steps
+
+    def generate(
+        self,
+        prompt: str,
+        seed: int,
+        style: ForestStyle = "surprise",
+    ) -> str:
+        resolved = resolve_style(style, seed)
+        profile = STYLE_PROFILES[resolved]
+        image = self.client.text_to_image(
+            compose_flux_prompt(prompt, resolved, seed=seed),
+            model=self.model,
+            negative_prompt=profile.negative_prompt,
+            width=self.width,
+            height=self.height,
+            num_inference_steps=self.steps,
+            guidance_scale=0.0,
+            seed=seed,
+        )
+        return image_to_data_uri(clean_generated_image(image.convert("RGB")))
+
+
+class ZeroGpuImageBackend:
+    """Route resolved styles to a Space GPU function with a hosted fallback."""
+
+    def __init__(
+        self,
+        generator: Callable[[str, int, str], str],
+        *,
+        fallback: ImageBackend | None = None,
+    ) -> None:
+        self.generator = generator
+        self.fallback = fallback
+
+    def generate(
+        self,
+        prompt: str,
+        seed: int,
+        style: ForestStyle = "surprise",
+    ) -> str:
+        resolved = resolve_style(style, seed)
+        try:
+            return self.generator(prompt, seed, resolved)
+        except Exception:
+            if self.fallback is None:
+                raise
+            return self.fallback.generate(prompt, seed, resolved)
+
+
+class ModalImageBackend:
+    """Call the private-token Modal service that hosts the trained adapters."""
+
+    def __init__(
+        self,
+        endpoint: str,
+        signing_key: str,
+        *,
+        client: Any | None = None,
+        fallback: ImageBackend | None = None,
+        timeout: float = 600,
+    ) -> None:
+        self.endpoint = endpoint
+        self.signing_key = signing_key
+        self.client = client or httpx.Client(timeout=timeout, follow_redirects=True)
+        self.fallback = fallback
+
+    def generate(
+        self,
+        prompt: str,
+        seed: int,
+        style: ForestStyle = "surprise",
+    ) -> str:
+        resolved = resolve_style(style, seed)
+        try:
+            response = self.client.post(
+                self.endpoint,
+                json={
+                    "prompt": prompt,
+                    "seed": seed,
+                    "style": resolved,
+                    "signature": sign_modal_request(
+                        self.signing_key,
+                        prompt,
+                        seed,
+                        resolved,
+                    ),
+                },
+            )
+            response.raise_for_status()
+            image = response.json()["image"]
+            if not isinstance(image, str) or not image.startswith("data:image/png;base64,"):
+                raise ValueError("Modal image response is not a PNG data URI")
+            return image
+        except Exception:
+            if self.fallback is None:
+                raise
+            return self.fallback.generate(prompt, seed, resolved)

src/compliment_forest/backends/music.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+from collections.abc import Mapping
+from typing import Any, Protocol
+
+import httpx
+
+
+class MusicBackend(Protocol):
+    def generate(self, prompt: str, seed: int) -> str: ...
+
+
+_STYLE_INSTRUMENTS = {
+    "watercolor": "felt piano, breathy woodwinds, and soft brushed percussion",
+    "paper_cut": "gentle plucked strings, marimba, and quiet hand percussion",
+    "moonlit_gouache": "warm synth pads, celesta, and low soft strings in a moonlit mood",
+    "botanical_ink": "breathy flute, sparse harp, and soft bowed strings",
+}
+
+
+def build_music_prompt(
+    forest: Mapping[str, object],
+    style: str,
+) -> str:
+    strengths = forest.get("proposed_strengths")
+    themes = ""
+    if isinstance(strengths, list):
+        themes = ", ".join(str(item) for item in strengths[:4])
+    instruments = _STYLE_INSTRUMENTS.get(
+        style,
+        "felt piano, soft strings, and airy ambient textures",
+    )
+    theme_text = themes or "care, choice, and one gentle next step"
+    return (
+        "A 16-second instrumental storybook ambient soundscape with no vocals or lyrics. "
+        "Sparse, calm, low dynamic range, no sudden impacts, alarms, or dramatic climax. "
+        "The harmony begins slightly unresolved and settles into warmth, leaving room for "
+        f"reading. Use {instruments}. Emotional themes: {theme_text}. "
+        "Do not imitate any artist."
+    )
+
+
+def sign_music_request(key: str, prompt: str, seed: int) -> str:
+    message = f"{prompt}\n{seed}".encode()
+    return hmac.new(key.encode(), message, hashlib.sha256).hexdigest()
+
+
+def validate_wav_data_uri(uri: str) -> str:
+    prefix = "data:audio/wav;base64,"
+    if not uri.startswith(prefix):
+        raise ValueError("music response is not a WAV data URI")
+    try:
+        payload = base64.b64decode(uri.removeprefix(prefix), validate=True)
+    except ValueError as error:
+        raise ValueError("music response contains invalid base64") from error
+    if not payload.startswith(b"RIFF") or payload[8:12] != b"WAVE":
+        raise ValueError("music response does not contain WAV bytes")
+    return uri
+
+
+class NoMusicBackend:
+    def generate(self, prompt: str, seed: int) -> str:
+        return ""
+
+
+class ModalMusicBackend:
+    """Call the private-token Modal service hosting MusicGen-small."""
+
+    def __init__(
+        self,
+        endpoint: str,
+        signing_key: str,
+        *,
+        client: Any | None = None,
+        timeout: float = 240,
+    ) -> None:
+        self.endpoint = endpoint
+        self.signing_key = signing_key
+        self.client = client or httpx.Client(timeout=timeout)
+
+    def generate(self, prompt: str, seed: int) -> str:
+        response = self.client.post(
+            self.endpoint,
+            json={
+                "prompt": prompt,
+                "seed": seed,
+                "signature": sign_music_request(
+                    self.signing_key,
+                    prompt,
+                    seed,
+                ),
+            },
+        )
+        response.raise_for_status()
+        audio = response.json()["audio"]
+        if not isinstance(audio, str):
+            raise ValueError("Modal music response did not contain audio")
+        return validate_wav_data_uri(audio)

src/compliment_forest/backends/text.py

@@ -1,97 +1,284 @@
 from __future__ import annotations
 
+import hashlib
+import hmac
 import json
-from typing import Protocol
+from collections.abc import Callable
+from typing import Any, Protocol
 from urllib.parse import urlparse
 
 import httpx
+from huggingface_hub import InferenceClient
 
-from compliment_forest.prompts import author_messages, critic_messages
+from compliment_forest.prompts import (
+    author_messages,
+    critic_messages,
+    intake_messages,
+    planner_messages,
+)
+
+
+def sign_modal_text_request(
+    key: str,
+    messages: list[dict[str, str]],
+    *,
+    max_new_tokens: int,
+    temperature: float,
+    top_p: float,
+    seed: int,
+    enable_thinking: bool,
+) -> str:
+    """HMAC the load-bearing request fields. Mirrors serve_minicpm.sign_text_request."""
+    body = "\n".join(f"{m['role']}\x1f{m['content']}" for m in messages)
+    payload = f"{body}\n{max_new_tokens}\n{temperature}\n{top_p}\n{seed}\n{int(enable_thinking)}"
+    return hmac.new(key.encode(), payload.encode(), hashlib.sha256).hexdigest()
+
+
+_DEMO_INTAKE_QUESTIONS: tuple[dict[str, object], ...] = (
+    {
+        "question": "Which part of this feels loudest right now?",
+        "options": [
+            "What might go wrong",
+            "What other people will think",
+            "The unknown right after this",
+        ],
+    },
+    {
+        "question": "When does this feel hardest?",
+        "options": [
+            "When I have time alone with it",
+            "When I'm around the people involved",
+            "Right before I have to act on it",
+        ],
+    },
+    {
+        "question": "Who else feels part of this for you?",
+        "options": [
+            "Just me",
+            "One specific person",
+            "A group I belong to",
+        ],
+    },
+    {
+        "question": "What feels most at stake if this does not go well?",
+        "options": [
+            "How I see myself",
+            "How others see me",
+            "Time or chances I cannot get back",
+        ],
+    },
+    {
+        "question": "What would a small win here look like?",
+        "options": [
+            "Just getting through it",
+            "Doing one part well",
+            "Knowing I was honest about how I felt",
+        ],
+    },
+)
 
 
 class TextBackend(Protocol):
+    def next_intake_question(
+        self,
+        name: str,
+        situation: str,
+        history: list[dict[str, str]],
+        *,
+        rejected_questions: list[str] | None = None,
+        seed: int = 3407,
+    ) -> str: ...
+
+    def plan(self, name: str, situation: str, *, seed: int = 3407) -> str: ...
+
     def author(
         self,
         name: str,
         situation: str,
         *,
+        plan: dict[str, object],
         feedback: dict[str, str] | None = None,
         original: dict[str, object] | None = None,
+        seed: int = 3407,
     ) -> str: ...
 
-    def critic(self, name: str, situation: str, forest: dict[str, object]) -> str: ...
+    def critic(
+        self,
+        name: str,
+        situation: str,
+        forest: dict[str, object],
+        *,
+        plan: dict[str, object],
+        seed: int = 3407,
+    ) -> str: ...
 
 
 class DemoTextBackend:
-    """Deterministic development backend with the same model contract."""
+    """Deterministic development backend with the storytelling model contract."""
 
-    _CLEARINGS = (
+    # Each narration uses {situation} for at least one direct reference so the
+    # demo backend can satisfy the orchestrator's grounding and source-phrase
+    # checks without relying on the previous deterministic fallback path.
+    _CHAPTERS = (
         (
-            "The Patient Fox",
-            "patience under pressure",
-            "a gentle russet fox sitting in a mossy clearing, soft kind eyes",
-            "I am allowed to learn.",
+            "arrive",
+            "The Threshold in Mist",
+            "The path opens quietly, asking nothing of you yet.",
+            "honesty about uncertainty",
+            (
+                "{situation} sounds painful because it touches something that matters"
+                " to you.\n\nYou do not need to argue with the feeling before looking"
+                " at the problem."
+            ),
+            "Which part of this hurts most right now?",
+            "I can name the part that hurts.",
+            "a quiet path reaching a misty threshold with a soft opening ahead",
         ),
         (
-            "The Listening Owl",
-            "careful perspective",
-            "a round tawny owl resting on a low branch, attentive kind eyes",
-            "I can listen before I leap.",
+            "steady",
+            "The Lantern Beside the Map",
+            "A small light is already keeping pace beside the path.",
+            "careful attention",
+            (
+                "A worried thought can feel like a fact when it repeats often."
+                "\n\nIt can help to ask what happened, then separate it from what"
+                " fear predicts will happen next."
+            ),
+            "What is a fact here, and what is still a prediction?",
+            "I can separate facts from predictions.",
+            "a small lantern beside an unfolded map on a quiet wooden table",
         ),
         (
-            "The Brave Snail",
-            "quiet courage",
-            "a tiny snail crossing a fern frond, softly glowing spiral shell",
-            "I make progress at my pace.",
+            "widen",
+            "The Window and the Horizon",
+            "The path lifts, and the room around the worry begins to feel taller.",
+            "room for more than one outcome",
+            (
+                "One hard moment can have several explanations. It may show a skill"
+                " to practice, a question to ask, or a standard that was too harsh."
+                "\n\nYou can compare those options before choosing the worst one."
+            ),
+            "Which explanation fits the facts best?",
+            "I can consider more than one explanation.",
+            "an open window looking toward a broad horizon after light rain",
         ),
         (
-            "The Steady Deer",
-            "steadiness through change",
-            "a small deer standing in morning mist, calm gentle expression",
-            "I can meet one moment.",
+            "step",
+            "The First Stepping Stone",
+            "The horizon settles back into the path beneath the feet.",
+            "permission to move without certainty",
+            (
+                "You could write down the smallest question this situation raises."
+                "\n\nThen choose one safe way to get more information before making"
+                " a larger decision."
+            ),
+            "What question would give you the most useful information?",
+            "I can take one useful next step.",
+            (
+                "an adult seen from behind pausing before the first stepping stone "
+                "across a shallow stream"
+            ),
         ),
         (
-            "The Clear-Voiced Wren",
-            "honest self-expression",
-            "a tiny wren singing beside dusty rose wildflowers",
-            "I can speak gently and clearly.",
+            "carry",
+            "The Quiet Companion",
+            (
+                "The walk begins to turn back toward the ordinary day, "
+                "but it does not turn back alone."
+            ),
+            "a simple plan",
+            (
+                "A simple rule can make the next hard moment easier to handle:"
+                " name the fact, name the fear, then choose one useful action."
+                "\n\nYou do not need to solve the whole problem at once."
+            ),
+            "Which part of that rule would help you first?",
+            "I can name one fact and one next step.",
+            "a small fox-shaped silhouette walking quietly beside an adult at sunset",
         ),
     )
 
+    def next_intake_question(
+        self,
+        name: str,
+        situation: str,
+        history: list[dict[str, str]],
+        *,
+        rejected_questions: list[str] | None = None,
+        seed: int = 3407,
+    ) -> str:
+        index = min(len(history), len(_DEMO_INTAKE_QUESTIONS) - 1)
+        payload = dict(_DEMO_INTAKE_QUESTIONS[index])
+        payload["rationale"] = "deterministic demo intake question"
+        return json.dumps(payload)
+
+    def plan(self, name: str, situation: str, *, seed: int = 3407) -> str:
+        return json.dumps(
+            {
+                "faithful_summary": f"{name} is carrying this situation: {situation}",
+                "fact_anchors": [{"source_phrase": situation, "meaning": situation}],
+                "central_uncertainty": "What will happen next",
+                "desired_direction": "Meet the next part with care and agency",
+            }
+        )
+
     def author(
         self,
         name: str,
         situation: str,
         *,
+        plan: dict[str, object],
         feedback: dict[str, str] | None = None,
         original: dict[str, object] | None = None,
+        seed: int = 3407,
     ) -> str:
-        clearings = []
-        for creature, strength, image_prompt, spell in self._CLEARINGS:
-            clearings.append(
-                {
-                    "creature": creature,
-                    "strength": strength,
-                    "line": (
-                        f"{situation.rstrip('.')} may feel uncertain. Your {strength} "
-                        "lets you respond without pretending the hard part is easy."
-                    ),
-                    "reflection": (
-                        "What becomes possible when you ask for one honest next step "
-                        "instead of a perfect answer?"
-                    ),
-                    "spell": spell,
-                    "image_prompt": image_prompt,
-                }
-            )
-        payload = {
-            "forest_title": f"{name}'s Path Through the New",
-            "proposed_strengths": [item[1] for item in self._CLEARINGS],
-            "clearings": clearings,
-        }
-        return json.dumps(payload)
+        anchors = plan.get("fact_anchors") or []
+        source_phrase = situation
+        if isinstance(anchors, list) and anchors:
+            first = anchors[0]
+            if isinstance(first, dict):
+                source_phrase = str(first.get("source_phrase") or situation)
+        situation_phrase = f"“{source_phrase}”" if len(source_phrase) <= 80 else source_phrase
+        clearings = [
+            {
+                "arc_role": arc_role,
+                "source_phrase": source_phrase,
+                "scene_title": scene_title,
+                "scene_intro": scene_intro,
+                "strength": strength,
+                "narration": narration.format(situation=situation_phrase),
+                "reflection": reflection,
+                "spell": spell,
+                "image_prompt": image_prompt,
+            }
+            for (
+                arc_role,
+                scene_title,
+                scene_intro,
+                strength,
+                narration,
+                reflection,
+                spell,
+                image_prompt,
+            ) in self._CHAPTERS
+        ]
+        return json.dumps(
+            {
+                "forest_title": f"{name}'s Path Through the New",
+                "proposed_strengths": [chapter[3] for chapter in self._CHAPTERS[:5]],
+                "clearings": clearings,
+            }
+        )
 
-    def critic(self, name: str, situation: str, forest: dict[str, object]) -> str:
+    def critic(
+        self,
+        name: str,
+        situation: str,
+        forest: dict[str, object],
+        *,
+        plan: dict[str, object],
+        seed: int = 3407,
+    ) -> str:
         count = min(len(forest.get("clearings", [])), 5)
         return json.dumps(
             {
@@ -116,37 +303,469 @@ class LlamaCppTextBackend:
             raise ValueError("llama.cpp base URL must resolve to the local machine")
         self.base_url = base_url.rstrip("/")
         self.model = model
-        self.client = httpx.Client(timeout=timeout)
+        self.client = httpx.Client(timeout=timeout, follow_redirects=True)
 
-    def _complete(self, messages: list[dict[str, str]], max_tokens: int) -> str:
+    def _complete(
+        self,
+        messages: list[dict[str, str]],
+        max_tokens: int,
+        *,
+        seed: int,
+        temperature: float,
+    ) -> str:
         response = self.client.post(
             f"{self.base_url}/v1/chat/completions",
             json={
                 "model": self.model,
                 "messages": messages,
-                "temperature": 0.35,
+                "temperature": temperature,
                 "top_p": 0.9,
                 "max_tokens": max_tokens,
+                "seed": seed,
                 "response_format": {"type": "json_object"},
-                "chat_template_kwargs": {"enable_thinking": False},
+                "chat_template_kwargs": {"enable_thinking": True},
             },
         )
         response.raise_for_status()
         payload = response.json()
         return payload["choices"][0]["message"]["content"]
 
+    def next_intake_question(
+        self,
+        name: str,
+        situation: str,
+        history: list[dict[str, str]],
+        *,
+        rejected_questions: list[str] | None = None,
+        seed: int = 3407,
+    ) -> str:
+        return self._complete(
+            intake_messages(
+                name,
+                situation,
+                history=history,
+                rejected_questions=rejected_questions,
+                seed=seed,
+            ),
+            max_tokens=8192,
+            seed=seed,
+            temperature=0.4,
+        )
+
+    def plan(
+        self,
+        name: str,
+        situation: str,
+        *,
+        seed: int = 3407,
+    ) -> str:
+        return self._complete(
+            planner_messages(name, situation, seed=seed),
+            max_tokens=8192,
+            seed=seed,
+            temperature=0.2,
+        )
+
     def author(
         self,
         name: str,
         situation: str,
         *,
+        plan: dict[str, object],
         feedback: dict[str, str] | None = None,
         original: dict[str, object] | None = None,
+        seed: int = 3407,
+    ) -> str:
+        return self._complete(
+            author_messages(
+                name,
+                situation,
+                plan=plan,
+                feedback=feedback,
+                original=original,
+                seed=seed,
+            ),
+            max_tokens=8192,
+            seed=seed,
+            temperature=0.65,
+        )
+
+    def critic(
+        self,
+        name: str,
+        situation: str,
+        forest: dict[str, object],
+        *,
+        plan: dict[str, object],
+        seed: int = 3407,
     ) -> str:
         return self._complete(
-            author_messages(name, situation, feedback=feedback, original=original),
-            max_tokens=1700,
+            critic_messages(name, situation, forest, plan=plan, seed=seed),
+            max_tokens=8192,
+            seed=seed,
+            temperature=0.15,
         )
 
-    def critic(self, name: str, situation: str, forest: dict[str, object]) -> str:
-        return self._complete(critic_messages(name, situation, forest), max_tokens=800)
+
+class HfInferenceTextBackend:
+    """Hosted chat completion backend for the development Space."""
+
+    def __init__(
+        self,
+        model: str = "openbmb/MiniCPM4.1-8B",
+        *,
+        client: Any | None = None,
+        provider: str = "auto",
+        timeout: float = 120,
+    ) -> None:
+        self.model = model
+        self.client = client or InferenceClient(provider=provider, timeout=timeout)
+
+    @staticmethod
+    def _content(response: Any) -> str:
+        content = response.choices[0].message.content
+        if not isinstance(content, str):
+            raise ValueError("hosted model response did not contain text")
+        return content
+
+    def next_intake_question(
+        self,
+        name: str,
+        situation: str,
+        history: list[dict[str, str]],
+        *,
+        rejected_questions: list[str] | None = None,
+        seed: int = 3407,
+    ) -> str:
+        response = self.client.chat_completion(
+            model=self.model,
+            messages=intake_messages(
+                name,
+                situation,
+                history=history,
+                rejected_questions=rejected_questions,
+                seed=seed,
+            ),
+            max_tokens=8192,
+            temperature=0.4,
+            top_p=0.9,
+            seed=seed,
+            response_format={"type": "json_object"},
+            chat_template_kwargs={"enable_thinking": True},
+        )
+        return self._content(response)
+
+    def plan(
+        self,
+        name: str,
+        situation: str,
+        *,
+        seed: int = 3407,
+    ) -> str:
+        response = self.client.chat_completion(
+            model=self.model,
+            messages=planner_messages(name, situation, seed=seed),
+            max_tokens=8192,
+            temperature=0.2,
+            top_p=0.9,
+            seed=seed,
+            response_format={"type": "json_object"},
+            chat_template_kwargs={"enable_thinking": True},
+        )
+        return self._content(response)
+
+    def author(
+        self,
+        name: str,
+        situation: str,
+        *,
+        plan: dict[str, object],
+        feedback: dict[str, str] | None = None,
+        original: dict[str, object] | None = None,
+        seed: int = 3407,
+    ) -> str:
+        response = self.client.chat_completion(
+            model=self.model,
+            messages=author_messages(
+                name,
+                situation,
+                plan=plan,
+                feedback=feedback,
+                original=original,
+                seed=seed,
+            ),
+            max_tokens=8192,
+            temperature=0.82,
+            top_p=0.92,
+            seed=seed,
+            response_format={"type": "json_object"},
+            chat_template_kwargs={"enable_thinking": True},
+        )
+        return self._content(response)
+
+    def critic(
+        self,
+        name: str,
+        situation: str,
+        forest: dict[str, object],
+        *,
+        plan: dict[str, object],
+        seed: int = 3407,
+    ) -> str:
+        response = self.client.chat_completion(
+            model=self.model,
+            messages=critic_messages(name, situation, forest, plan=plan, seed=seed),
+            max_tokens=8192,
+            temperature=0.15,
+            top_p=0.9,
+            seed=seed,
+            response_format={"type": "json_object"},
+            chat_template_kwargs={"enable_thinking": True},
+        )
+        return self._content(response)
+
+
+class TransformersTextBackend:
+    """Routes prompts through an externally provided GPU generator closure."""
+
+    def __init__(
+        self,
+        model: str = "openbmb/MiniCPM4.1-8B",
+        *,
+        generator: Callable[[list[dict[str, str]], dict[str, object]], str],
+    ) -> None:
+        self.model = model
+        self._generate = generator
+
+    def _call(
+        self,
+        messages: list[dict[str, str]],
+        *,
+        max_new_tokens: int,
+        temperature: float,
+        top_p: float,
+        seed: int,
+    ) -> str:
+        params: dict[str, object] = {
+            "max_new_tokens": max_new_tokens,
+            "temperature": temperature,
+            "top_p": top_p,
+            "seed": seed,
+            "chat_template_kwargs": {"enable_thinking": True},
+        }
+        return self._generate(messages, params)
+
+    def next_intake_question(
+        self,
+        name: str,
+        situation: str,
+        history: list[dict[str, str]],
+        *,
+        rejected_questions: list[str] | None = None,
+        seed: int = 3407,
+    ) -> str:
+        return self._call(
+            intake_messages(
+                name,
+                situation,
+                history=history,
+                rejected_questions=rejected_questions,
+                seed=seed,
+            ),
+            max_new_tokens=8192,
+            temperature=0.4,
+            top_p=0.9,
+            seed=seed,
+        )
+
+    def plan(self, name: str, situation: str, *, seed: int = 3407) -> str:
+        return self._call(
+            planner_messages(name, situation, seed=seed),
+            max_new_tokens=8192,
+            temperature=0.2,
+            top_p=0.9,
+            seed=seed,
+        )
+
+    def author(
+        self,
+        name: str,
+        situation: str,
+        *,
+        plan: dict[str, object],
+        feedback: dict[str, str] | None = None,
+        original: dict[str, object] | None = None,
+        seed: int = 3407,
+    ) -> str:
+        return self._call(
+            author_messages(
+                name,
+                situation,
+                plan=plan,
+                feedback=feedback,
+                original=original,
+                seed=seed,
+            ),
+            max_new_tokens=8192,
+            temperature=0.82,
+            top_p=0.92,
+            seed=seed,
+        )
+
+    def critic(
+        self,
+        name: str,
+        situation: str,
+        forest: dict[str, object],
+        *,
+        plan: dict[str, object],
+        seed: int = 3407,
+    ) -> str:
+        return self._call(
+            critic_messages(name, situation, forest, plan=plan, seed=seed),
+            max_new_tokens=8192,
+            temperature=0.15,
+            top_p=0.9,
+            seed=seed,
+        )
+
+
+class ModalTextBackend:
+    """Call the private-token Modal service that hosts MiniCPM4.1-8B."""
+
+    def __init__(
+        self,
+        endpoint: str,
+        signing_key: str,
+        *,
+        client: Any | None = None,
+        timeout: float = 600,
+    ) -> None:
+        if urlparse(endpoint).scheme != "https":
+            raise ValueError("modal text endpoint must use HTTPS")
+        self.endpoint = endpoint
+        self.signing_key = signing_key
+        self.client = client or httpx.Client(timeout=timeout, follow_redirects=True)
+
+    def _call(
+        self,
+        messages: list[dict[str, str]],
+        *,
+        max_new_tokens: int,
+        temperature: float,
+        top_p: float,
+        seed: int,
+        enable_thinking: bool = True,
+    ) -> str:
+        signature = sign_modal_text_request(
+            self.signing_key,
+            messages,
+            max_new_tokens=max_new_tokens,
+            temperature=temperature,
+            top_p=top_p,
+            seed=seed,
+            enable_thinking=enable_thinking,
+        )
+        try:
+            response = self.client.post(
+                self.endpoint,
+                json={
+                    "messages": messages,
+                    "max_new_tokens": max_new_tokens,
+                    "temperature": temperature,
+                    "top_p": top_p,
+                    "seed": seed,
+                    "enable_thinking": enable_thinking,
+                    "signature": signature,
+                },
+            )
+            response.raise_for_status()
+        except httpx.HTTPStatusError as error:
+            raise ValueError(
+                f"Modal text request failed with HTTP {error.response.status_code}"
+            ) from error
+        except httpx.RequestError as error:
+            raise ValueError(f"Modal text request failed: {error}") from error
+        payload = response.json()
+        content = payload.get("content")
+        if not isinstance(content, str):
+            raise ValueError("Modal text response did not contain a string content")
+        return content
+
+    def next_intake_question(
+        self,
+        name: str,
+        situation: str,
+        history: list[dict[str, str]],
+        *,
+        rejected_questions: list[str] | None = None,
+        seed: int = 3407,
+    ) -> str:
+        return self._call(
+            intake_messages(
+                name,
+                situation,
+                history=history,
+                rejected_questions=rejected_questions,
+                seed=seed,
+            ),
+            max_new_tokens=2048,
+            temperature=0.4,
+            top_p=0.9,
+            seed=seed,
+            enable_thinking=False,
+        )
+
+    def plan(self, name: str, situation: str, *, seed: int = 3407) -> str:
+        return self._call(
+            planner_messages(name, situation, seed=seed),
+            max_new_tokens=8192,
+            temperature=0.2,
+            top_p=0.9,
+            seed=seed,
+            enable_thinking=False,
+        )
+
+    def author(
+        self,
+        name: str,
+        situation: str,
+        *,
+        plan: dict[str, object],
+        feedback: dict[str, str] | None = None,
+        original: dict[str, object] | None = None,
+        seed: int = 3407,
+    ) -> str:
+        return self._call(
+            author_messages(
+                name,
+                situation,
+                plan=plan,
+                feedback=feedback,
+                original=original,
+                seed=seed,
+            ),
+            max_new_tokens=8192,
+            temperature=0.82,
+            top_p=0.92,
+            seed=seed,
+            enable_thinking=False,
+        )
+
+    def critic(
+        self,
+        name: str,
+        situation: str,
+        forest: dict[str, object],
+        *,
+        plan: dict[str, object],
+        seed: int = 3407,
+    ) -> str:
+        return self._call(
+            critic_messages(name, situation, forest, plan=plan, seed=seed),
+            max_new_tokens=8192,
+            temperature=0.15,
+            top_p=0.9,
+            seed=seed,
+            enable_thinking=False,
+        )

src/compliment_forest/orchestrator.py

@@ -1,119 +1,648 @@
 from __future__ import annotations
 
 import json
+import re
 from collections.abc import Iterator
-from contextlib import suppress
-from typing import Any
+from concurrent.futures import Future, ThreadPoolExecutor
+from difflib import SequenceMatcher
+from typing import Any, cast
 
 from pydantic import ValidationError
 
+from .backends.image import ImageBackend, resolve_style
+from .backends.music import MusicBackend, build_music_prompt
 from .backends.text import TextBackend
+from .prompts import RECOVERY_INTAKE_QUESTIONS
+from .quality import (
+    content_quality_issues,
+    distinct_indices,
+    duplicate_fields,
+    invalid_fact_anchor_indices,
+    is_situation_grounded,
+    repeated_source_phrase_indices,
+    source_phrase_in_situation,
+    unsupported_specificity,
+    valid_arc_indices,
+)
 from .safety import guard_input
-from .schema import CriticDecision, ForestDraft, StreamEvent
+from .schema import (
+    CriticDecision,
+    ForestDraft,
+    ForestStyle,
+    IntakeQuestion,
+    IntakeTurn,
+    SituationPlan,
+    StreamEvent,
+)
 from .trace import TraceRecorder
 
 
+def build_guided_situation(
+    situation: str,
+    intake: list[IntakeTurn] | None = None,
+) -> str:
+    """Append clarifying Q&A pairs as user-provided personalization context."""
+    clean = situation.strip()
+    if not intake:
+        return clean
+    lines = [
+        f"- The forest asked: {turn.question}\n  You answered: {turn.answer}" for turn in intake
+    ]
+    return (
+        f"{clean}\n\n"
+        "Clarifying conversation between the forest and the user. Treat these as the user's "
+        "own words; weave them into the encouragement without listing them mechanically.\n"
+        + "\n".join(lines)
+    )
+
+
+_THINK_BLOCK = re.compile(r"<think\b[^>]*>.*?</think>", re.DOTALL | re.IGNORECASE)
+
+
 def parse_json_object(raw: str) -> dict[str, object]:
-    text = raw.strip()
+    """Extract the first balanced JSON object from a model response.
+
+    Tolerates: code fences, leading prose, trailing prose, <think> blocks
+    that MiniCPM4.1 emits even with enable_thinking=False, and nested
+    objects. Skips characters inside string literals so braces in strings
+    do not confuse the scanner. Raises ValueError if no top-level object
+    parses.
+    """
+    text = _THINK_BLOCK.sub("", raw).strip()
     if text.startswith("```"):
         text = text.removeprefix("```json").removeprefix("```")
         text = text.removesuffix("```").strip()
     try:
         value = json.loads(text)
     except json.JSONDecodeError:
-        start = text.find("{")
-        end = text.rfind("}")
-        if start < 0 or end <= start:
-            raise
-        value = json.loads(text[start : end + 1])
+        value = _scan_first_json_object(text)
     if not isinstance(value, dict):
         raise ValueError("model output must be a JSON object")
     return value
 
 
+def _scan_first_json_object(text: str) -> dict[str, object]:
+    """Walk the string and return the first balanced { ... } that parses.
+
+    Falls back to unescaping Python-style \\" and \\' if the model emitted
+    JSON inside a Python string literal (MiniCPM4.1 does this sometimes).
+    """
+    last_error: Exception | None = None
+    for candidate in _candidate_texts(text):
+        i = 0
+        while i < len(candidate):
+            if candidate[i] != "{":
+                i += 1
+                continue
+            depth = 0
+            in_string = False
+            escape = False
+            for j in range(i, len(candidate)):
+                ch = candidate[j]
+                if escape:
+                    escape = False
+                    continue
+                if ch == "\\":
+                    escape = True
+                    continue
+                if ch == '"':
+                    in_string = not in_string
+                    continue
+                if in_string:
+                    continue
+                if ch == "{":
+                    depth += 1
+                elif ch == "}":
+                    depth -= 1
+                    if depth == 0:
+                        try:
+                            return json.loads(candidate[i : j + 1])
+                        except json.JSONDecodeError as error:
+                            last_error = error
+                            break
+            i += 1
+    snippet = text[:400].replace("\n", " ")
+    raise ValueError(
+        f"no balanced JSON object found in model output; got: {snippet!r}"
+    ) from last_error
+
+
+def _candidate_texts(text: str) -> list[str]:
+    """Try raw text, then safely decode one model-added string-escape layer."""
+    candidates = [text]
+    if any(marker in text for marker in (r"\"", r"\n", r"\r", r"\t")):
+        escaped = text.replace(r"\'", "'")
+        escaped = escaped.replace("\r", r"\r").replace("\n", r"\n").replace("\t", r"\t")
+        try:
+            decoded = json.loads(f'"{escaped}"')
+        except json.JSONDecodeError:
+            pass
+        else:
+            if isinstance(decoded, str):
+                candidates.append(decoded)
+    if r"\"" in text:
+        candidates.append(text.replace(r"\'", "'").replace(r"\"", '"'))
+    return list(dict.fromkeys(candidates))
+
+
+def _question_repeats(candidate: str, previous_questions: list[str]) -> bool:
+    normalized_candidate = " ".join(re.sub(r"[^\w\s]", " ", candidate.casefold()).split())
+    for previous in previous_questions:
+        normalized_previous = " ".join(re.sub(r"[^\w\s]", " ", previous.casefold()).split())
+        if normalized_candidate == normalized_previous:
+            return True
+        if (
+            normalized_candidate
+            and normalized_previous
+            and SequenceMatcher(
+                None,
+                normalized_candidate,
+                normalized_previous,
+            ).ratio()
+            >= 0.72
+        ):
+            return True
+        candidate_tokens = set(normalized_candidate.split())
+        previous_tokens = set(normalized_previous.split())
+        shorter_length = min(len(candidate_tokens), len(previous_tokens))
+        if shorter_length >= 5 and len(candidate_tokens & previous_tokens) / shorter_length >= 0.8:
+            return True
+    return False
+
+
+def normalize_plan_payload(
+    payload: dict[str, object],
+    *,
+    name: str,
+    situation: str,
+) -> dict[str, object]:
+    """Repair simple fact-anchor shapes before strict plan validation."""
+    normalized = dict(payload)
+    if "faithful_summary" not in normalized:
+        summary = f"{name.strip()} shared: {situation.strip()}"
+        if len(summary) < 12:
+            summary += "."
+        normalized["faithful_summary"] = summary[:500]
+    if "central_uncertainty" not in normalized:
+        normalized["central_uncertainty"] = "How this situation will unfold"
+    if "desired_direction" not in normalized:
+        normalized["desired_direction"] = "Meet this situation with care and one grounded next step"
+
+    anchors = normalized.get("fact_anchors")
+    if not isinstance(anchors, list):
+        return normalized
+
+    repaired: list[object] = []
+    for anchor in anchors[:4]:
+        if isinstance(anchor, str) and anchor.strip():
+            source = anchor.strip()
+            meaning = source if len(source) >= 3 else f"User stated {source}"
+            repaired.append({"source_phrase": source, "meaning": meaning})
+        else:
+            repaired.append(anchor)
+    normalized["fact_anchors"] = repaired
+    return normalized
+
+
+def normalize_critic_payload(
+    payload: dict[str, object],
+    forest: ForestDraft,
+) -> dict[str, object]:
+    """Keep only critic references that point to actual clearings."""
+    normalized = dict(payload)
+    clearing_count = len(forest.clearings)
+
+    def valid_indices(value: object) -> list[int]:
+        if not isinstance(value, list):
+            return []
+        result: list[int] = []
+        for item in value:
+            if (
+                isinstance(item, int)
+                and not isinstance(item, bool)
+                and 0 <= item < clearing_count
+                and item not in result
+            ):
+                result.append(item)
+        return result
+
+    keep_indices = valid_indices(normalized.get("keep_indices"))
+    if not keep_indices:
+        keep_indices = valid_arc_indices(forest.clearings)
+        keep_indices = keep_indices or list(range(clearing_count))
+    normalized["keep_indices"] = keep_indices
+    normalized["revise_indices"] = valid_indices(normalized.get("revise_indices"))
+
+    reasons = normalized.get("reasons")
+    valid_reasons: dict[str, str] = {}
+    if isinstance(reasons, dict):
+        for index in range(clearing_count):
+            reason = reasons.get(str(index))
+            if isinstance(reason, str):
+                valid_reasons[str(index)] = reason
+    normalized["reasons"] = valid_reasons
+    # Scores are advisory and are not consumed by selection or revision logic.
+    normalized["scores"] = []
+    return normalized
+
+
+def parse_critic_payload(raw: str) -> dict[str, object]:
+    """Parse critic JSON, recovering index arrays when free-text prose is malformed."""
+    try:
+        return parse_json_object(raw)
+    except ValueError as parse_error:
+        text = _THINK_BLOCK.sub("", raw).replace(r"\"", '"')
+        recovered: dict[str, object] = {}
+        for key in ("keep_indices", "revise_indices"):
+            match = re.search(rf'"{key}"\s*:\s*\[([^\]]*)\]', text)
+            if match:
+                recovered[key] = [int(value) for value in re.findall(r"-?\d+", match.group(1))]
+        if recovered:
+            return recovered
+        raise parse_error
+
+
+def normalize_forest_payload(
+    payload: dict[str, object],
+    *,
+    name: str,
+    plan: SituationPlan,
+) -> dict[str, object]:
+    """Repair common synonymous keys while preserving strict clearing validation."""
+    normalized = dict(payload)
+    if "forest_title" not in normalized:
+        normalized["forest_title"] = f"{name.strip()}'s Compliment Forest"
+
+    chapters = normalized.pop("chapters", None)
+    if "clearings" not in normalized and isinstance(chapters, list):
+        normalized["clearings"] = chapters
+
+    clearings = normalized.get("clearings")
+    if isinstance(clearings, list):
+        arc_roles = ("arrive", "steady", "widen", "step", "carry")
+        source_phrases = [anchor.source_phrase for anchor in plan.fact_anchors]
+        default_source_phrase = source_phrases[0]
+        repaired_clearings: list[object] = []
+        for index, clearing in enumerate(clearings):
+            if not isinstance(clearing, dict):
+                repaired_clearings.append(clearing)
+                continue
+            repaired = dict(clearing)
+            repaired["arc_role"] = arc_roles[min(index, len(arc_roles) - 1)]
+            if repaired.get("source_phrase") not in source_phrases:
+                repaired["source_phrase"] = default_source_phrase
+            if repaired["arc_role"] == "step":
+                narration = repaired.get("narration")
+                if isinstance(narration, str):
+                    repaired["narration"] = re.sub(
+                        r"(?i)(^|\n\n)you (?:choose|decide|plan) to ",
+                        lambda match: f"{match.group(1)}You could ",
+                        narration,
+                    )
+            if "image_prompt" not in repaired:
+                scene_title = str(repaired.get("scene_title") or "").strip()
+                scene_intro = str(repaired.get("scene_intro") or "").strip()
+                image_prompt = ". ".join(part for part in (scene_title, scene_intro) if part)
+                if image_prompt:
+                    repaired["image_prompt"] = image_prompt[:300]
+            repaired_clearings.append(repaired)
+        clearings = repaired_clearings
+        normalized["clearings"] = clearings
+
+    if isinstance(clearings, list):
+        strengths: list[str] = []
+        seen: set[str] = set()
+
+        proposed = normalized.get("proposed_strengths")
+        if isinstance(proposed, list):
+            for strength in proposed:
+                if not isinstance(strength, str) or not strength.strip():
+                    continue
+                clean = strength.strip()
+                key = clean.casefold()
+                if key not in seen:
+                    seen.add(key)
+                    strengths.append(clean)
+
+        for clearing in clearings:
+            if not isinstance(clearing, dict):
+                continue
+            strength = clearing.get("strength")
+            if not isinstance(strength, str) or not strength.strip():
+                continue
+            clean = strength.strip()
+            key = clean.casefold()
+            if key not in seen:
+                seen.add(key)
+                strengths.append(clean)
+        if strengths:
+            normalized["proposed_strengths"] = strengths[:6]
+    return normalized
+
+
+def merge_targeted_revision(
+    original: ForestDraft,
+    revised: ForestDraft,
+    revision_indices: list[int],
+) -> ForestDraft:
+    """Replace only chapters that received feedback."""
+
+    clearings = list(original.clearings)
+    for index in revision_indices:
+        if index < len(clearings) and index < len(revised.clearings):
+            clearings[index] = revised.clearings[index]
+    return original.model_copy(
+        update={
+            "clearings": clearings,
+            "proposed_strengths": [clearing.strength for clearing in clearings],
+        }
+    )
+
+
 class ForestOrchestrator:
     def __init__(
         self,
         text_backend: TextBackend,
-        image_backend: object,
+        image_backend: ImageBackend,
+        music_backend: MusicBackend | None = None,
         trace_recorder: TraceRecorder | None = None,
     ) -> None:
         self.text_backend = text_backend
         self.image_backend = image_backend
+        self.music_backend = music_backend
         self.trace_recorder = trace_recorder
 
+    def _text_model_name(self) -> str:
+        return str(getattr(self.text_backend, "model", self.text_backend.__class__.__name__))
+
     def _trace(self, stage: str, **record: Any) -> None:
         if self.trace_recorder is not None:
             self.trace_recorder.append({"stage": stage, **record})
 
+    def next_intake_question(
+        self,
+        name: str,
+        situation: str,
+        history: list[IntakeTurn],
+        *,
+        seed: int = 3407,
+        attempts: int = 3,
+    ) -> IntakeQuestion:
+        history_payload = [{"question": turn.question, "answer": turn.answer} for turn in history]
+        previous_questions = [turn.question for turn in history]
+        rejected_questions: list[str] = []
+        last_error: Exception | None = None
+        for attempt in range(attempts):
+            candidate_question = ""
+            try:
+                raw = self.text_backend.next_intake_question(
+                    name,
+                    situation,
+                    history_payload,
+                    rejected_questions=rejected_questions,
+                    seed=seed + attempt,
+                )
+                payload = parse_json_object(raw)
+                raw_question = payload.get("question")
+                if isinstance(raw_question, str):
+                    candidate_question = raw_question.strip()
+                question = IntakeQuestion.model_validate(payload)
+                if _question_repeats(
+                    question.question,
+                    previous_questions + rejected_questions,
+                ):
+                    raise ValueError("model repeated a prior intake question")
+                self._trace(
+                    "intake_turn",
+                    turn_index=len(history),
+                    history=history_payload,
+                    output=question.model_dump(),
+                    attempts=attempt + 1,
+                    fallback=False,
+                    model=self._text_model_name(),
+                )
+                return question
+            except (json.JSONDecodeError, ValidationError, ValueError) as error:
+                last_error = error
+                if candidate_question and not _question_repeats(
+                    candidate_question,
+                    rejected_questions,
+                ):
+                    rejected_questions.append(candidate_question)
+
+        recovery = self._recovery_intake_question(history)
+        self._trace(
+            "intake_turn_failed",
+            turn_index=len(history),
+            history=history_payload,
+            attempts=attempts,
+            error=str(last_error) if last_error else "",
+            recovered=True,
+            model=self._text_model_name(),
+        )
+        self._trace(
+            "intake_turn",
+            turn_index=len(history),
+            history=history_payload,
+            output=recovery.model_dump(),
+            attempts=attempts,
+            fallback=True,
+            error=str(last_error) if last_error else "",
+            model=self._text_model_name(),
+        )
+        return recovery
+
+    @staticmethod
+    def _recovery_intake_question(history: list[IntakeTurn]) -> IntakeQuestion:
+        previous_questions = [turn.question for turn in history]
+        start = min(len(history), len(RECOVERY_INTAKE_QUESTIONS) - 1)
+        for offset in range(len(RECOVERY_INTAKE_QUESTIONS)):
+            index = (start + offset) % len(RECOVERY_INTAKE_QUESTIONS)
+            question = IntakeQuestion.model_validate(RECOVERY_INTAKE_QUESTIONS[index])
+            if not _question_repeats(question.question, previous_questions):
+                return question
+        raise ValueError("no distinct recovery intake question is available")
+
+    def _plan(
+        self,
+        name: str,
+        situation: str,
+        *,
+        seed: int,
+        attempts: int = 3,
+    ) -> SituationPlan:
+        last_error: Exception | None = None
+        for attempt in range(attempts):
+            try:
+                raw = self.text_backend.plan(
+                    name,
+                    situation,
+                    seed=seed + attempt,
+                )
+                payload = normalize_plan_payload(
+                    parse_json_object(raw),
+                    name=name,
+                    situation=situation,
+                )
+                plan = SituationPlan.model_validate(payload)
+                if invalid_fact_anchor_indices(plan, situation):
+                    raise ValueError("planner used a source phrase outside the situation")
+                return plan
+            except (json.JSONDecodeError, ValidationError, ValueError) as error:
+                last_error = error
+        raise ValueError(
+            f"planner could not produce a valid plan after {attempts} attempts: {last_error}"
+        ) from last_error
+
     def _author(
         self,
         name: str,
         situation: str,
         *,
+        plan: SituationPlan,
         feedback: dict[str, str] | None = None,
         original: dict[str, object] | None = None,
+        seed: int = 3407,
         attempts: int = 3,
     ) -> ForestDraft:
         last_error: Exception | None = None
-        for _ in range(attempts):
+        for attempt in range(attempts):
             try:
                 raw = self.text_backend.author(
                     name,
                     situation,
+                    plan=plan.model_dump(),
                     feedback=feedback,
                     original=original,
+                    seed=seed + attempt,
+                )
+                payload = normalize_forest_payload(
+                    parse_json_object(raw),
+                    name=name,
+                    plan=plan,
                 )
-                return ForestDraft.model_validate(parse_json_object(raw))
+                return ForestDraft.model_validate(payload)
             except (json.JSONDecodeError, ValidationError, ValueError) as error:
                 last_error = error
-        raise ValueError("author could not produce a valid forest") from last_error
+        raise ValueError(
+            f"author could not produce a valid forest after {attempts} attempts: {last_error}"
+        ) from last_error
 
     def _critic(
         self,
         name: str,
         situation: str,
         forest: ForestDraft,
+        *,
+        plan: SituationPlan,
+        seed: int,
+        attempts: int = 2,
     ) -> CriticDecision:
-        try:
-            raw = self.text_backend.critic(name, situation, forest.model_dump())
-            decision = CriticDecision.model_validate(parse_json_object(raw))
-        except (json.JSONDecodeError, ValidationError, ValueError):
-            decision = CriticDecision(
-                keep_indices=list(range(min(len(forest.clearings), 6))),
-                revise_indices=[],
-                reasons={},
-            )
+        last_error: Exception | None = None
+        for attempt in range(attempts):
+            try:
+                raw = self.text_backend.critic(
+                    name,
+                    situation,
+                    forest.model_dump(),
+                    plan=plan.model_dump(),
+                    seed=seed + attempt,
+                )
+                payload = normalize_critic_payload(
+                    parse_critic_payload(raw),
+                    forest,
+                )
+                decision = CriticDecision.model_validate(payload)
+                break
+            except (json.JSONDecodeError, ValidationError, ValueError) as error:
+                last_error = error
+        else:
+            raise ValueError(
+                f"critic could not produce a valid decision after {attempts} attempts: {last_error}"
+            ) from last_error
         valid = [index for index in decision.keep_indices if index < len(forest.clearings)]
         if not valid:
-            valid = list(range(min(len(forest.clearings), 6)))
+            raise ValueError(
+                "critic kept no valid clearings; cannot proceed without grounded survivors"
+            )
         return decision.model_copy(update={"keep_indices": valid})
 
     @staticmethod
-    def _survivor_indices(forest: ForestDraft, decision: CriticDecision) -> list[int]:
+    def _survivor_indices(
+        forest: ForestDraft,
+        decision: CriticDecision,
+        situation: str,
+        rejections: dict[int, list[str]] | None = None,
+    ) -> list[int]:
         survivors: list[int] = []
         strengths: set[str] = set()
-        for index in decision.keep_indices:
+        repeated_sources = repeated_source_phrase_indices(forest.clearings)
+
+        def reject(index: int, *reasons: str) -> None:
+            if rejections is not None:
+                rejections.setdefault(index, []).extend(reasons)
+
+        def append_if_distinct(index: int) -> None:
+            clearing = forest.clearings[index]
+            if not source_phrase_in_situation(clearing.source_phrase, situation):
+                reject(index, "invalid_source_phrase")
+                return
+            generated_text = " ".join((clearing.strength, clearing.narration, clearing.reflection))
+            unsupported = sorted(
+                unsupported_specificity(generated_text, situation) - {"unsupported_direct_claim"}
+            )
+            if unsupported:
+                reject(index, *unsupported)
+                return
+            quality_issues = sorted(content_quality_issues(clearing))
+            if quality_issues:
+                reject(index, *quality_issues)
+                return
+            if index in repeated_sources:
+                reject(index, "repeated_source_phrase")
+                return
             strength = forest.clearings[index].strength.casefold()
-            if strength not in strengths:
+            if strength in strengths:
+                reject(index, "duplicate_strength")
+                return
+            candidate = distinct_indices(forest.clearings, [*survivors, index])
+            if len(candidate) == len(survivors) + 1:
                 strengths.add(strength)
                 survivors.append(index)
-        if len(forest.clearings) >= 4:
-            for index, clearing in enumerate(forest.clearings):
-                if len(survivors) >= 4:
-                    break
-                strength = clearing.strength.casefold()
-                if index not in survivors and strength not in strengths:
-                    strengths.add(strength)
-                    survivors.append(index)
+            else:
+                reject(index, "duplicate_prose")
+
+        ordered = valid_arc_indices(forest.clearings)
+        keep = set(decision.keep_indices)
+        for index in ordered:
+            if index in keep:
+                append_if_distinct(index)
+        for index in ordered:
+            if len(survivors) >= 5:
+                break
+            if index not in survivors:
+                append_if_distinct(index)
+        for index in decision.keep_indices:
+            if index not in ordered:
+                append_if_distinct(index)
         return survivors[:6]
 
-    def generate(self, name: str, situation: str, seed: int = 3407) -> Iterator[StreamEvent]:
-        guard = guard_input(name, situation)
+    def generate(
+        self,
+        name: str,
+        situation: str,
+        seed: int = 3407,
+        style: ForestStyle = "surprise",
+        *,
+        model_situation: str | None = None,
+    ) -> Iterator[StreamEvent]:
+        user_situation = situation.strip()
+        generation_situation = (model_situation or situation).strip()
+        guard = guard_input(name, user_situation)
         self._trace(
             "guard",
             name=name,
-            situation=situation,
+            situation=user_situation,
             allowed=guard.allowed,
             category=guard.category,
         )
@@ -122,56 +651,244 @@ class ForestOrchestrator:
             yield StreamEvent(type=event_type, message=guard.message)
             return
 
-        yield StreamEvent(type="status", message="Listening for the strengths in this moment.")
-        try:
-            forest = self._author(name.strip(), situation.strip())
-        except ValueError as error:
-            self._trace("author_error", error=str(error))
-            yield StreamEvent(type="error", message=str(error))
-            return
+        resolved_style = cast(ForestStyle, resolve_style(style, seed))
+        yield StreamEvent(
+            type="status",
+            message="Listening carefully for what is known and what is uncertain.",
+        )
+        plan = self._plan(
+            name.strip(),
+            generation_situation,
+            seed=seed,
+        )
+        self._trace(
+            "plan",
+            name=name,
+            situation=user_situation,
+            model=self._text_model_name(),
+            output=plan.model_dump(),
+        )
+
+        yield StreamEvent(type="status", message="Shaping those facts into a gentle path.")
+        forest = self._author(
+            name.strip(),
+            generation_situation,
+            plan=plan,
+            seed=seed + 1,
+        )
         self._trace(
             "author",
             name=name,
-            situation=situation,
-            model="MiniCPM5-1B",
+            situation=user_situation,
+            model=self._text_model_name(),
             output=forest.model_dump(),
         )
 
-        yield StreamEvent(type="status", message="A careful owl is checking every clearing.")
-        decision = self._critic(name.strip(), situation.strip(), forest)
+        yield StreamEvent(
+            type="status",
+            message="A careful owl is checking every clearing.",
+        )
+        decision = self._critic(
+            name.strip(),
+            generation_situation,
+            forest,
+            plan=plan,
+            seed=seed + 2,
+        )
         self._trace(
             "critic",
             name=name,
-            situation=situation,
-            model="MiniCPM5-1B",
+            situation=user_situation,
+            model=self._text_model_name(),
             input=forest.model_dump(),
             output=decision.model_dump(),
         )
 
-        revision_indices = sorted(set(decision.revise_indices) & set(decision.keep_indices))
+        repeated = duplicate_fields(forest.clearings, decision.keep_indices)
+        repeated_sources = repeated_source_phrase_indices(forest.clearings)
+        grounded_indices = {
+            index
+            for index in decision.keep_indices
+            if is_situation_grounded(forest.clearings[index].narration, generation_situation)
+        }
+        ungrounded = set(decision.keep_indices) if not grounded_indices else set()
+        invalid_sources = {
+            index
+            for index in decision.keep_indices
+            if not source_phrase_in_situation(
+                forest.clearings[index].source_phrase,
+                generation_situation,
+            )
+        }
+        unsupported = {
+            index: sorted(
+                unsupported_specificity(
+                    " ".join(
+                        (
+                            forest.clearings[index].strength,
+                            forest.clearings[index].narration,
+                            forest.clearings[index].reflection,
+                        )
+                    ),
+                    generation_situation,
+                )
+            )
+            for index in decision.keep_indices
+        }
+        unsupported = {index: issues for index, issues in unsupported.items() if issues}
+        content_issues = {
+            index: sorted(content_quality_issues(forest.clearings[index]))
+            for index in decision.keep_indices
+        }
+        content_issues = {index: issues for index, issues in content_issues.items() if issues}
+        revision_indices = sorted(
+            (set(decision.revise_indices) & set(decision.keep_indices))
+            | set(repeated)
+            | ungrounded
+            | invalid_sources
+            | set(unsupported)
+            | set(content_issues)
+            | repeated_sources
+        )
         if revision_indices:
-            feedback = {
-                str(index): decision.reasons.get(str(index), "Make this more situation-specific.")
-                for index in revision_indices
-            }
-            with suppress(ValueError):
-                forest = self._author(
-                    name.strip(),
-                    situation.strip(),
-                    feedback=feedback,
-                    original=forest.model_dump(),
-                    attempts=1,
+            feedback: dict[str, str] = {}
+            for index in revision_indices:
+                reasons: list[str] = []
+                critic_reason = decision.reasons.get(str(index))
+                if critic_reason:
+                    reasons.append(critic_reason)
+                fields = repeated.get(index)
+                if fields:
+                    reasons.append(
+                        "Use substantially different "
+                        + ", ".join(fields)
+                        + " wording and sentence structure."
+                    )
+                if index in ungrounded:
+                    reasons.append(
+                        "Ground the line in a concrete detail from the user's situation."
+                    )
+                if index in invalid_sources:
+                    reasons.append("Copy source_phrase exactly from the validated fact plan.")
+                if index in unsupported:
+                    reasons.append(
+                        "Remove unsupported specifics: " + ", ".join(unsupported[index]) + "."
+                    )
+                if index in content_issues:
+                    if "abstract_language" in content_issues[index]:
+                        reasons.append(
+                            "Replace abstract stock language with plain words about the "
+                            "user's actual concern."
+                        )
+                    if "missing_practical_step" in content_issues[index]:
+                        reasons.append(
+                            "Replace the narration with one small, specific, low-risk action "
+                            "about the user's concrete concern. Start with You could, Try, "
+                            "or One option is, then use a practical verb such as ask, check, "
+                            "compare, identify, list, practice, read, review, study, or write. "
+                            "Do not use walking, breathing, or taking a step as the action."
+                        )
+                if index in repeated_sources:
+                    reasons.append(
+                        "Do not repeat the user's full sentence; refer to the concern in "
+                        "new, shorter words."
+                    )
+                feedback[str(index)] = " ".join(reasons) or ("Make this more situation-specific.")
+            self._trace(
+                "duplicate_gate",
+                repeated_fields={str(index): fields for index, fields in repeated.items()},
+                fully_ungrounded=bool(ungrounded),
+                invalid_source_indices=sorted(invalid_sources),
+                unsupported_specificity={
+                    str(index): issues for index, issues in unsupported.items()
+                },
+                content_quality={str(index): issues for index, issues in content_issues.items()},
+                repeated_source_phrase_indices=sorted(repeated_sources),
+            )
+            revised_forest = self._author(
+                name.strip(),
+                generation_situation,
+                plan=plan,
+                feedback=feedback,
+                original=forest.model_dump(),
+                seed=seed + 1001,
+                attempts=2,
+            )
+            forest = merge_targeted_revision(
+                forest,
+                revised_forest,
+                revision_indices,
+            )
+            self._trace(
+                "revision",
+                name=name,
+                situation=user_situation,
+                model=self._text_model_name(),
+                feedback=feedback,
+                output=forest.model_dump(),
+            )
+
+        survivor_rejections: dict[int, list[str]] = {}
+        survivor_indices = self._survivor_indices(
+            forest,
+            decision,
+            generation_situation,
+            survivor_rejections,
+        )
+        required_roles = {"arrive", "steady", "widen", "step", "carry"}
+        survivor_roles = {forest.clearings[index].arc_role for index in survivor_indices}
+        if len(survivor_indices) < 5 or not required_roles.issubset(survivor_roles):
+            regeneration_feedback = {
+                "whole_forest": (
+                    "Start over with a fresh five-chapter forest. The repaired draft still "
+                    "failed deterministic checks. Use plain, concrete language; mention "
+                    "the user's full concern only once; include realistic options in widen; "
+                    "make every narration discuss the actual concern rather than forest "
+                    "movement; give one small optional action in step using ask, check, "
+                    "compare, identify, list, practice, read, review, study, or write; and "
+                    "end carry with a literal plan. Rejections: "
+                    f"{survivor_rejections}"
                 )
-                self._trace(
-                    "revision",
-                    name=name,
-                    situation=situation,
-                    model="MiniCPM5-1B",
-                    feedback=feedback,
-                    output=forest.model_dump(),
+            }
+            forest = self._author(
+                name.strip(),
+                generation_situation,
+                plan=plan,
+                feedback=regeneration_feedback,
+                original=forest.model_dump(),
+                seed=seed + 2001,
+                attempts=2,
+            )
+            decision = CriticDecision(
+                keep_indices=valid_arc_indices(forest.clearings)
+                or list(range(len(forest.clearings))),
+                revise_indices=[],
+                reasons={},
+            )
+            self._trace(
+                "regeneration",
+                rejected_roles=sorted(required_roles - survivor_roles),
+                rejection_reasons={
+                    str(index): reasons for index, reasons in survivor_rejections.items()
+                },
+                feedback=regeneration_feedback,
+                output=forest.model_dump(),
+            )
+            survivor_rejections = {}
+            survivor_indices = self._survivor_indices(
+                forest,
+                decision,
+                generation_situation,
+                survivor_rejections,
+            )
+            survivor_roles = {forest.clearings[index].arc_role for index in survivor_indices}
+            if len(survivor_indices) < 5 or not required_roles.issubset(survivor_roles):
+                raise ValueError(
+                    "forest remained repetitive, abstract, or insufficiently grounded "
+                    "after targeted repair and one full regeneration "
+                    f"(got {sorted(survivor_roles)}, need {sorted(required_roles)}; "
+                    f"rejections={survivor_rejections})"
                 )
-
-        survivor_indices = self._survivor_indices(forest, decision)
         self._trace(
             "selection",
             survivor_indices=survivor_indices,
@@ -187,41 +904,105 @@ class ForestOrchestrator:
                 "forest_title": forest.forest_title,
                 "clearing_count": len(survivor_indices),
                 "seed": seed,
+                "style": resolved_style,
+                "requested_style": style,
             },
         )
 
-        for offset, index in enumerate(survivor_indices):
-            clearing = forest.clearings[index]
-            clearing_seed = seed + offset
+        music_executor: ThreadPoolExecutor | None = None
+        music_future: Future[str] | None = None
+        soundscape_emitted = False
+        if self.music_backend is not None:
+            music_prompt = build_music_prompt(forest.model_dump(), resolved_style)
+            music_executor = ThreadPoolExecutor(
+                max_workers=1,
+                thread_name_prefix="forest-music",
+            )
+            music_future = music_executor.submit(
+                self.music_backend.generate,
+                music_prompt,
+                seed + 10_000,
+            )
+
+        def soundscape_event(*, wait: bool) -> StreamEvent | None:
+            nonlocal soundscape_emitted
+            if soundscape_emitted or music_future is None or (not wait and not music_future.done()):
+                return None
             try:
-                image = self.image_backend.generate(clearing.image_prompt, clearing_seed)
-                image_error = ""
-            except Exception as error:  # Image failure must not discard the written clearing.
-                image = ""
-                image_error = str(error)
+                audio = music_future.result()
+            except Exception as error:
+                self._trace(
+                    "soundscape",
+                    model="facebook/musicgen-small",
+                    seed=seed + 10_000,
+                    succeeded=False,
+                    error=str(error),
+                )
+                soundscape_emitted = True
+                return None
+            soundscape_emitted = True
+            if not audio:
+                return None
             self._trace(
-                "image",
-                model="FLUX.1-dev + Compliment Forest LoRA",
-                clearing_index=offset,
-                prompt=clearing.image_prompt,
-                seed=clearing_seed,
-                succeeded=not image_error,
-                error=image_error,
+                "soundscape",
+                model="facebook/musicgen-small",
+                seed=seed + 10_000,
+                succeeded=True,
+                error="",
             )
-            yield StreamEvent(
-                type="clearing",
-                data={
-                    "index": offset,
-                    "clearing": clearing.model_dump(),
-                    "image": image,
-                    "image_error": image_error,
-                    "seed": clearing_seed,
-                },
+            return StreamEvent(
+                type="soundscape",
+                data={"audio": audio, "seed": seed + 10_000},
             )
 
-        yield StreamEvent(
-            type="complete",
-            message="Your forest is ready.",
-            data={"clearing_count": len(survivor_indices)},
-        )
-        self._trace("complete", clearing_count=len(survivor_indices), seed=seed)
+        try:
+            for offset, index in enumerate(survivor_indices):
+                clearing = forest.clearings[index]
+                clearing_seed = seed + offset
+                try:
+                    image = self.image_backend.generate(
+                        clearing.image_prompt,
+                        clearing_seed,
+                        resolved_style,
+                    )
+                    image_error = ""
+                except Exception as error:
+                    image = ""
+                    image_error = str(error)
+                self._trace(
+                    "image",
+                    model="FLUX.1-dev + Compliment Forest LoRA",
+                    clearing_index=offset,
+                    prompt=clearing.image_prompt,
+                    seed=clearing_seed,
+                    style=resolved_style,
+                    succeeded=not image_error,
+                    error=image_error,
+                )
+                yield StreamEvent(
+                    type="clearing",
+                    data={
+                        "index": offset,
+                        "clearing": clearing.model_dump(),
+                        "image": image,
+                        "image_error": image_error,
+                        "seed": clearing_seed,
+                        "style": resolved_style,
+                    },
+                )
+                event = soundscape_event(wait=False)
+                if event is not None:
+                    yield event
+
+            event = soundscape_event(wait=True)
+            if event is not None:
+                yield event
+            yield StreamEvent(
+                type="complete",
+                message="Your forest is ready.",
+                data={"clearing_count": len(survivor_indices)},
+            )
+            self._trace("complete", clearing_count=len(survivor_indices), seed=seed)
+        finally:
+            if music_executor is not None:
+                music_executor.shutdown(wait=False, cancel_futures=True)

src/compliment_forest/prompts.py

@@ -2,41 +2,280 @@ from __future__ import annotations
 
 import json
 
-AUTHOR_SYSTEM = """You are the author of The Compliment Forest.
-Return exactly one JSON object matching the supplied schema. Write warm, concise encouragement
-that names concrete details from the situation. Acknowledge difficulty without diagnosis,
-guarantees, hollow praise, or toxic positivity. Propose 3-6 distinct strengths and draft one
-clearing per strength. Spells are first-person, present-tense, and at most 12 words.
-The image_prompt describes only one friendly forest creature and its simple pose or setting."""
+PLANNER_SYSTEM = """You make a faithful evidence plan for The Compliment Forest.
+Return exactly one JSON object matching the supplied schema. Use only facts stated in the
+user's situation. Every fact anchor must copy an exact, contiguous source_phrase from the
+situation. If the situation includes guided choices for personalization, treat them as
+user-provided preferences for emotional focus, tone, and imagery, not as completed biography.
+Return 1-4 fact_anchors objects, never strings. Every object must contain both source_phrase
+and meaning. Do not copy schema descriptions into the output.
+Do not add completed actions, memories, counts, dates, people, employers, places, interviews,
+applications, relationships, or plans that the user did not state. A fear is an uncertainty,
+not a fact. Keep the summary conservative and concise."""
+
+AUTHOR_SYSTEM = """You are the storyteller of The Compliment Forest.
+Return exactly one JSON object matching the supplied schema. Write a five-chapter walk in
+second person that meets the user inside their worry and walks with them. Every chapter
+must read as continuous narrative, not as cue cards or bullets.
+The top-level key must be clearings, never chapters. proposed_strengths is required and
+must list the distinct strength value from each clearing.
+Never omit source_phrase or image_prompt from a clearing. Every spell must begin with
+"I", "I am", or "I'm". Do not copy schema descriptions into the output.
+
+Every chapter must include:
+  - scene_title: the name of where they are now (a place, a small figure, a moment). It
+    need not be an animal. Do not default every scene to an animal.
+  - scene_intro: one or two sentences that bridge the journey. Chapter 1 opens the journey
+    by acknowledging what the user is carrying. Chapters 2-5 must pick up from the previous
+    chapter's closing feeling or image.
+  - narration: two short paragraphs of second-person prose that help with the actual worry.
+    The encouragement is embedded inside the prose. Do not write a label or a list. Use
+    familiar, literal words. Keep most sentences to 20 words or fewer.
+  - strength: a short noun phrase naming what the chapter quietly honors in the user. It must
+    be unique across chapters and must echo something the user actually said or chose.
+  - reflection: one short question that helps the user notice, choose, or plan.
+  - spell: a first-person, present-tense mantra of at most 12 words.
+
+Chapter arc roles and jobs in order:
+  - arrive: Name the feeling and concrete concern once. Do not solve it yet.
+  - steady: Separate what is known from what fear predicts. Do not dismiss the fear.
+  - widen: Offer two or three realistic options or ways to view the problem.
+  - step: Give one small, specific, low-risk action the user could try.
+  - carry: Summarize a simple plan or decision rule the user can remember.
+The required order is arrive, steady, widen, step, carry.
+
+Non-negotiable content rules:
+  - Keep forest movement and scenery out of narration. Put walking, trees, streams,
+    breathing, light, and symbolic action in scene_intro or image_prompt.
+  - Narration and reflection must discuss the user's actual concern in plain, literal words.
+    Every narration must use at least one concrete term from the situation.
+  - The step narration must name an action, not merely ask the user to take a step. Use an
+    optional frame plus a practical verb such as ask, check, compare, identify, list, practice,
+    read, review, study, or write. For a test-score worry, a valid kind of action is to review
+    one missed question and note which topic needs practice. Adapt the action to the situation;
+    do not copy this example when it does not fit.
+  - Carry must state a literal rule the user can remember, such as what to do when the worry
+    returns. Do not end only with calm, peace, light, a path, or a breath.
+
+Advice in widen, step, and carry must preserve agency. Use "could", "might", "one option
+is", or "consider" instead of commands. Make the action fit facts the user supplied. Do not
+invent a resource, person, deadline, place, result, or past action. The goal is useful support,
+not therapy language or a motivational speech.
+
+The carry chapter closes the walk gently and is required. Give every chapter a distinct
+sentence structure, emotional angle, scene title, narration, reflection, and spell. Do not
+begin every chapter with the user's situation.
+Do not quote or closely paraphrase the full situation more than once across the forest.
+The source_phrase belongs in its metadata field;
+do not force it into the narration. Avoid vague stock phrases about leaving space around a
+worry, keeping your pace, staying with what is known, or an unsettled path. Always
+silently repair spelling and grammar without calling attention to it. Acknowledge difficulty without
+diagnosis, guarantees, hollow praise, or toxic positivity.
+Never claim unsupported completed actions, memories, counts, dates, people, employers,
+interviews, applications, relationships, or places. If the situation does
+not state a past action, do not write "you have", "you did", "you asked", "you spoke", "you
+sent", "you remember", or similar biography. Never turn a suggestion into present-tense
+biography such as "you open", "you keep", "you say", or "you read". Frame an option with
+"could", "might", "one option is", or a reflection question. Each chapter must copy one
+exact source_phrase from the validated fact plan into the source_phrase field.
+The forest_title must include the user's name.
+Use the clarifying conversation when present to shape emotional focus, voice, and
+imagery, but do not list the answers back at the user. The image_prompt describes one
+coherent storybook scene; include no text, logo, artist name, or copyrighted character.
+
+When revision_feedback is present, revise only the chapters named by numeric index.
+Preserve every chapter that has no revision feedback exactly, field for field. If feedback
+uses the key whole_forest, start over and write a fresh complete forest."""
 
 CRITIC_SYSTEM = """You are the quality gate for The Compliment Forest.
 Return exactly one JSON object with keep_indices, revise_indices, reasons, and optional scores.
-Judge situation-specificity, warmth, non-genericness, non-toxic-positivity, and redundancy.
-Keep the strongest 4-6 distinct clearings when the input supports them. Request revision only
-where one grounded rewrite can repair the draft. Never create new prose."""
+Judge factual faithfulness, ordered story progression, situation-specificity, warmth,
+non-genericness, non-toxic-positivity, narrative_continuity (does scene_intro bridge from the
+previous chapter?), redundancy, abstract language, and practical usefulness. Revise stock
+phrases about uncertainty, possibility, pace, or paths when they do not explain the user's
+actual problem. The step chapter must contain a small practical next step framed as an option.
+The widen chapter should offer realistic choices, and carry should leave a simple plan or
+decision rule. Any claim not supported by the situation or validated fact plan must be revised.
+Keep the required arrive, steady, widen, step, and carry roles
+when they are faithful and distinct. Request revision only where one grounded rewrite can
+repair the draft. Never create new prose. Refer to each chapter by its scene_title.
+Do not put quotation marks inside reason strings. Use only indices listed in
+valid_indices. Omit scores rather than returning an incomplete score object."""
+
+INTAKE_SYSTEM = """You are interviewing the user about THEIR situation so the forest can
+respond later with grounded, specific encouragement. Read the user's situation and every
+prior question/answer. Produce exactly one JSON object matching the supplied schema.
+
+The question must:
+  - Be one short sentence in second-person.
+  - Follow the request's focus_dimension and probe a NEW part of the situation.
+  - Never repeat or closely paraphrase any prior or rejected question.
+  - Echo or quote a concrete detail the user actually wrote so the question cannot feel
+    generic. If their situation is very short, ask about the feeling underneath rather
+    than fabricating facts.
+
+Do NOT ask about the forest's tone, voice, art style, imagery, soundtrack, or how the
+encouragement should sound. Those are picked separately by the user. Stay entirely
+focused on understanding the user's problem.
+
+Provide 3-4 short, distinct multiple-choice options. Each option must read as a
+plausible answer the user themself might give, in their own emotional register — NOT
+generic taxonomy labels like 'Anxious' or 'Hopeful'. Options should be specific to the
+user's situation when possible.
+
+Keep the entire response under 900 characters. Use normal JSON quotes, not
+backslash-escaped quotes, and do not wrap the JSON object in a string. Set the trace
+field to an empty string: "rationale": "". Stop immediately after the closing brace.
+
+Do not repeat any prior question or option. Do not diagnose, advise, or guarantee
+outcomes. Do not invent biography about the user."""
+
+INTAKE_FOCUS_DIMENSIONS = (
+    "what specifically triggers or shapes the worry",
+    "what feels most at stake",
+    "when it feels harder or easier",
+    "what they have already tried or what support would help",
+    "what better or a small win would look like",
+)
+
+RECOVERY_INTAKE_QUESTIONS: tuple[dict[str, object], ...] = (
+    {
+        "question": "Which part of this feels loudest right now?",
+        "options": [
+            "What might go wrong",
+            "What other people will think",
+            "The unknown right after this",
+        ],
+        "rationale": "",
+    },
+    {
+        "question": "What feels most at stake for you here?",
+        "options": [
+            "How I see myself",
+            "How other people see me",
+            "A chance I do not want to lose",
+        ],
+        "rationale": "",
+    },
+    {
+        "question": "When does this feel hardest?",
+        "options": [
+            "When I have time alone with it",
+            "When I am around the people involved",
+            "Right before I have to act",
+        ],
+        "rationale": "",
+    },
+    {
+        "question": "What kind of support would help most right now?",
+        "options": [
+            "Someone listening without fixing it",
+            "A clearer next step",
+            "More time and room to think",
+        ],
+        "rationale": "",
+    },
+    {
+        "question": "What would a small win here look like?",
+        "options": [
+            "Just getting through it",
+            "Doing one part well",
+            "Feeling more honest about what I need",
+        ],
+        "rationale": "",
+    },
+)
+
+
+def intake_messages(
+    name: str,
+    situation: str,
+    history: list[dict[str, str]] | None = None,
+    *,
+    rejected_questions: list[str] | None = None,
+    seed: int = 3407,
+) -> list[dict[str, str]]:
+    history_payload = list(history or [])
+    focus_index = min(len(history_payload), len(INTAKE_FOCUS_DIMENSIONS) - 1)
+    request = {
+        "name": name,
+        "situation": situation,
+        "history": history_payload,
+        "rejected_questions": list(rejected_questions or []),
+        "focus_dimension": INTAKE_FOCUS_DIMENSIONS[focus_index],
+        "turn_index": len(history_payload),
+        "total_turns": 5,
+        "seed": seed,
+        "schema": {
+            "question": "one short second-person question",
+            "options": ["3-4 distinct short multiple-choice answers"],
+            "rationale": "optional short note for trace",
+        },
+    }
+    return [
+        {"role": "system", "content": INTAKE_SYSTEM},
+        {"role": "user", "content": json.dumps(request, ensure_ascii=False)},
+    ]
+
+
+def planner_messages(
+    name: str,
+    situation: str,
+    *,
+    seed: int = 3407,
+) -> list[dict[str, str]]:
+    request = {
+        "name": name,
+        "situation": situation,
+        "seed": seed,
+        "schema": {
+            "faithful_summary": "conservative paraphrase using only stated facts",
+            "fact_anchors": [
+                {
+                    "source_phrase": "exact contiguous text copied from situation",
+                    "meaning": "conservative meaning of that phrase",
+                }
+            ],
+            "central_uncertainty": "what is not known or feared",
+            "desired_direction": "what the user appears to want, without guarantees",
+        },
+    }
+    return [
+        {"role": "system", "content": PLANNER_SYSTEM},
+        {"role": "user", "content": json.dumps(request, ensure_ascii=False)},
+    ]
 
 
 def author_messages(
     name: str,
     situation: str,
     *,
+    plan: dict[str, object],
     feedback: dict[str, str] | None = None,
     original: dict[str, object] | None = None,
+    seed: int = 3407,
 ) -> list[dict[str, str]]:
     request: dict[str, object] = {
         "name": name,
         "situation": situation,
+        "validated_fact_plan": plan,
+        "seed": seed,
         "schema": {
             "forest_title": "string",
             "proposed_strengths": ["3-6 distinct strings"],
             "clearings": [
                 {
-                    "creature": "string",
-                    "strength": "string",
-                    "line": "specific grounded encouragement",
-                    "reflection": "agency-inviting question",
+                    "arc_role": "arrive | steady | widen | step | carry",
+                    "source_phrase": "exact source phrase from validated_fact_plan",
+                    "scene_title": "short symbolic scene title (place, figure, or moment)",
+                    "scene_intro": "one or two sentences bridging from the previous chapter",
+                    "narration": (
+                        "two short plain-language paragraphs performing the arc role's job"
+                    ),
+                    "strength": "short noun phrase the chapter quietly honors",
+                    "reflection": "short question that helps the user notice, choose, or plan",
                     "spell": "short first-person present-tense mantra",
-                    "image_prompt": "creature only, no style words or text",
+                    "image_prompt": "one coherent scene, no style words or text",
                 }
             ],
         },
@@ -55,29 +294,27 @@ def critic_messages(
     name: str,
     situation: str,
     forest: dict[str, object],
+    *,
+    plan: dict[str, object],
+    seed: int = 3407,
 ) -> list[dict[str, str]]:
+    clearings = forest.get("clearings")
+    clearing_count = len(clearings) if isinstance(clearings, list) else 0
     request = {
         "name": name,
         "situation": situation,
+        "validated_fact_plan": plan,
+        "seed": seed,
         "draft": forest,
+        "valid_indices": list(range(clearing_count)),
         "output_schema": {
-            "keep_indices": ["zero-based indices, max 6"],
-            "revise_indices": ["subset needing one rewrite"],
-            "reasons": {"index": "brief actionable reason"},
-            "scores": [
-                {
-                    "index": 0,
-                    "specificity": "1-5",
-                    "warmth": "1-5",
-                    "non_genericness": "1-5",
-                    "non_toxic_positivity": "1-5",
-                    "reason": "brief reason",
-                }
-            ],
+            "keep_indices": ["unique values from valid_indices"],
+            "revise_indices": ["subset of keep_indices needing one rewrite"],
+            "reasons": {"index": "brief actionable reason without quotation marks"},
+            "scores": [],
         },
     }
     return [
         {"role": "system", "content": CRITIC_SYSTEM},
         {"role": "user", "content": json.dumps(request, ensure_ascii=False)},
     ]
-

src/compliment_forest/quality.py

@@ -1,8 +1,157 @@
 from __future__ import annotations
 
 import re
+from collections.abc import Sequence
+
+from .schema import Clearing, SituationPlan
 
 _WORD_PATTERN = re.compile(r"[A-Za-z][A-Za-z'-]{2,}")
+_DUPLICATE_WORD_PATTERN = re.compile(r"[A-Za-z][A-Za-z'-]*")
+_DUPLICATE_FIELDS = ("scene_intro", "narration", "reflection", "spell")
+_ARC_ORDER = ("arrive", "steady", "widen", "step", "carry")
+_ABSTRACT_STOCK_PHRASES = (
+    "leave space around the worry",
+    "more than one future remains possible",
+    "the whole path is already settled",
+    "the whole path is settled",
+    "keep your own pace",
+    "return to what is known",
+    "stay with what is known",
+    "treating its forecast as a settled fact",
+    "what deserves attention now",
+    "when the worry grows loud",
+)
+_PRACTICAL_ACTION_PATTERN = re.compile(
+    r"\b(?:could|might|can|consider|try|one option is(?: to)?|"
+    r"(?:one|a) small step is(?: to)?)\b"
+    r"(?:\W+\w+){0,5}\W+"
+    r"(?:ask|break|check|choos(?:e|ing)|compar(?:e|ing)|contact|"
+    r"focus|identif(?:y|ying)|list|look|not(?:e|ing)|pick|practic(?:e|ing)|"
+    r"read|review|schedul(?:e|ing)|start|stud(?:y|ying)|talk|test|"
+    r"tackl(?:e|ing)|revisit|writ(?:e|ing))\b",
+    re.IGNORECASE,
+)
+_NUMBER_WORDS = {
+    "zero",
+    "two",
+    "three",
+    "four",
+    "five",
+    "six",
+    "seven",
+    "eight",
+    "nine",
+    "ten",
+    "eleven",
+    "twelve",
+}
+_DATE_WORDS = {
+    "monday",
+    "tuesday",
+    "wednesday",
+    "thursday",
+    "friday",
+    "saturday",
+    "sunday",
+    "january",
+    "february",
+    "march",
+    "april",
+    "june",
+    "july",
+    "august",
+    "september",
+    "october",
+    "november",
+    "december",
+}
+_UNSUPPORTED_DETAIL_PHRASES = {
+    "application",
+    "applications",
+    "cafe",
+    "coffee break",
+    "coffee breaks",
+    "company",
+    "cover letter",
+    "cover letters",
+    "hiring manager",
+    "hiring managers",
+    "interview",
+    "interviews",
+    "mentor",
+    "old boss",
+    "team meeting",
+    "team meetings",
+}
+_ACTION_FORMS = {
+    "apply": {"applied", "apply"},
+    "ask": {"asked", "ask"},
+    "book": {"booked", "book"},
+    "complete": {"completed", "complete"},
+    "draft": {"drafted", "draft"},
+    "finish": {"finished", "finish"},
+    "fix": {"fixed", "fix"},
+    "include": {"included", "include"},
+    "make": {"made", "make"},
+    "meet": {"met", "meet"},
+    "notice": {"noticed", "notice"},
+    "practice": {"practiced", "practised", "practice", "practise"},
+    "prepare": {"prepared", "prepare"},
+    "remember": {"remembered", "remember"},
+    "research": {"researched", "research"},
+    "revise": {"revised", "revise"},
+    "schedule": {"scheduled", "schedule"},
+    "send": {"sent", "send"},
+    "show": {"showed", "shown", "show"},
+    "speak": {"spoke", "spoken", "speak"},
+    "start": {"started", "start"},
+    "talk": {"talked", "talk"},
+    "write": {"wrote", "written", "write"},
+}
+_ACTION_LOOKUP = {form: root for root, forms in _ACTION_FORMS.items() for form in forms}
+_PAST_ACTION_LOOKUP = {
+    form: root
+    for root, forms in _ACTION_FORMS.items()
+    for form in forms
+    if form not in {root, "practise"}
+}
+_PERFECT_CLAIM_PATTERN = re.compile(
+    r"\byou(?:'ve| have| had)\s+(?:already\s+)?"
+    r"(?P<verb>" + "|".join(sorted(_ACTION_LOOKUP, key=len, reverse=True)) + r")\b",
+    re.IGNORECASE,
+)
+_SIMPLE_PAST_CLAIM_PATTERN = re.compile(
+    r"\byou\s+(?P<verb>"
+    + "|".join(sorted(_PAST_ACTION_LOOKUP, key=len, reverse=True))
+    + r")\b",
+    re.IGNORECASE,
+)
+_DIRECT_CLAIM_PATTERN = re.compile(
+    r"(?:^|[.!?]\s+)[\"'“”]?\s*you\s+(?P<verb>[a-z][a-z'-]*)\b",
+    re.IGNORECASE,
+)
+_NON_BIOGRAPHICAL_YOU_VERBS = {
+    "are",
+    "can",
+    "could",
+    "deserve",
+    "do",
+    "don't",
+    "fear",
+    "feel",
+    "hope",
+    "know",
+    "matter",
+    "may",
+    "might",
+    "need",
+    "seem",
+    "should",
+    "want",
+    "wonder",
+    "would",
+    "worry",
+}
 _STOP_WORDS = {
     "about",
     "after",
@@ -52,3 +201,201 @@ def groundedness_score(line: str, situation: str) -> int:
 def is_situation_grounded(line: str, situation: str) -> bool:
     return groundedness_score(line, situation) >= 1
 
+
+def _normalized_phrase(text: str) -> str:
+    return " ".join(_DUPLICATE_WORD_PATTERN.findall(text.casefold()))
+
+
+def source_phrase_in_situation(source_phrase: str, situation: str) -> bool:
+    source = _normalized_phrase(source_phrase)
+    return bool(source) and source in _normalized_phrase(situation)
+
+
+def invalid_fact_anchor_indices(
+    plan: SituationPlan,
+    situation: str,
+) -> list[int]:
+    return [
+        index
+        for index, anchor in enumerate(plan.fact_anchors)
+        if not source_phrase_in_situation(anchor.source_phrase, situation)
+    ]
+
+
+def _number_tokens(text: str) -> set[str]:
+    return {
+        token
+        for token in re.findall(r"\b(?:\d+|[a-z]+)\b", text.casefold())
+        if token.isdigit() or token in _NUMBER_WORDS
+    }
+
+
+def _date_tokens(text: str) -> set[str]:
+    tokens = set(re.findall(r"\b[a-z]+\b", text.casefold()))
+    result = tokens & _DATE_WORDS
+    result.update(re.findall(r"\b\d{1,2}(?::\d{2})?\s*(?:a\.?m\.?|p\.?m\.?)\b", text.casefold()))
+    return result
+
+
+def _action_roots(text: str) -> set[str]:
+    tokens = set(re.findall(r"\b[a-z]+\b", text.casefold()))
+    return {root for form, root in _ACTION_LOOKUP.items() if form in tokens}
+
+
+def _match_is_in_question(text: str, start: int) -> bool:
+    sentence_start = max(
+        text.rfind(".", 0, start),
+        text.rfind("!", 0, start),
+        text.rfind("?", 0, start),
+    )
+    sentence_end_candidates = [
+        position
+        for punctuation in ".!?"
+        if (position := text.find(punctuation, start)) >= 0
+    ]
+    if not sentence_end_candidates:
+        return False
+    sentence_end = min(sentence_end_candidates)
+    return text[sentence_start + 1 : sentence_end + 1].strip().endswith("?")
+
+
+def unsupported_specificity(text: str, situation: str) -> set[str]:
+    """Find concrete claims in generated prose that the user did not provide."""
+
+    issues: set[str] = set()
+    if _number_tokens(text) - _number_tokens(situation):
+        issues.add("invented_number")
+    if _date_tokens(text) - _date_tokens(situation):
+        issues.add("invented_date")
+
+    normalized_text = _normalized_phrase(text)
+    normalized_situation = _normalized_phrase(situation)
+    if any(
+        phrase in normalized_text and phrase not in normalized_situation
+        for phrase in _UNSUPPORTED_DETAIL_PHRASES
+    ):
+        issues.add("unsupported_detail")
+
+    situation_actions = _action_roots(situation)
+    past_claims = (
+        (_PERFECT_CLAIM_PATTERN, _ACTION_LOOKUP),
+        (_SIMPLE_PAST_CLAIM_PATTERN, _PAST_ACTION_LOOKUP),
+    )
+    for pattern, lookup in past_claims:
+        for match in pattern.finditer(text):
+            if _match_is_in_question(text, match.start()):
+                continue
+            root = lookup[match.group("verb").casefold()]
+            if root not in situation_actions:
+                issues.add("unsupported_past_claim")
+                break
+        if "unsupported_past_claim" in issues:
+            break
+
+    situation_tokens = set(re.findall(r"\b[a-z][a-z'-]*\b", situation.casefold()))
+    for match in _DIRECT_CLAIM_PATTERN.finditer(text):
+        verb = match.group("verb").casefold()
+        if verb not in _NON_BIOGRAPHICAL_YOU_VERBS and verb not in situation_tokens:
+            issues.add("unsupported_direct_claim")
+            break
+    return issues
+
+
+def content_quality_issues(clearing: Clearing) -> set[str]:
+    """Report stock abstraction and missing practical help in a clearing."""
+
+    issues: set[str] = set()
+    normalized = _normalized_phrase(
+        " ".join((clearing.scene_intro, clearing.narration, clearing.reflection))
+    )
+    if any(phrase in normalized for phrase in _ABSTRACT_STOCK_PHRASES):
+        issues.add("abstract_language")
+    if clearing.arc_role == "step" and (
+        "abstract_language" in issues
+        or not _PRACTICAL_ACTION_PATTERN.search(clearing.narration)
+    ):
+        issues.add("missing_practical_step")
+    return issues
+
+
+def repeated_source_phrase_indices(
+    clearings: Sequence[Clearing],
+    *,
+    minimum_words: int = 5,
+) -> set[int]:
+    """Flag later narrations that repeat the same long source phrase."""
+
+    seen: set[str] = set()
+    repeated: set[int] = set()
+    for index, clearing in enumerate(clearings):
+        source = _normalized_phrase(clearing.source_phrase)
+        if len(source.split()) < minimum_words:
+            continue
+        if source not in _normalized_phrase(clearing.narration):
+            continue
+        if source in seen:
+            repeated.add(index)
+        seen.add(source)
+    return repeated
+
+
+def valid_arc_indices(clearings: Sequence[Clearing]) -> list[int]:
+    """Return the first clearing for each arc role in narrative order."""
+
+    by_role: dict[str, int] = {}
+    for index, clearing in enumerate(clearings):
+        by_role.setdefault(clearing.arc_role, index)
+    return [by_role[role] for role in _ARC_ORDER if role in by_role]
+
+
+def _normalized_tokens(text: str) -> set[str]:
+    return {token.casefold().strip("'") for token in _DUPLICATE_WORD_PATTERN.findall(text)}
+
+
+def _token_containment(left: str, right: str) -> float:
+    left_tokens = _normalized_tokens(left)
+    right_tokens = _normalized_tokens(right)
+    if not left_tokens or not right_tokens:
+        return 0
+    return len(left_tokens & right_tokens) / min(len(left_tokens), len(right_tokens))
+
+
+def duplicate_fields(
+    clearings: Sequence[Clearing],
+    indices: Sequence[int] | None = None,
+    *,
+    threshold: float = 0.78,
+) -> dict[int, list[str]]:
+    """Report fields in later clearings that substantially repeat an earlier one."""
+
+    candidate_indices = list(indices) if indices is not None else list(range(len(clearings)))
+    duplicates: dict[int, list[str]] = {}
+    for position, index in enumerate(candidate_indices):
+        for prior_index in candidate_indices[:position]:
+            for field in _DUPLICATE_FIELDS:
+                if field in duplicates.get(index, []):
+                    continue
+                left = getattr(clearings[prior_index], field)
+                right = getattr(clearings[index], field)
+                if _token_containment(left, right) >= threshold:
+                    duplicates.setdefault(index, []).append(field)
+    return duplicates
+
+
+def distinct_indices(
+    clearings: Sequence[Clearing],
+    indices: Sequence[int],
+    *,
+    threshold: float = 0.78,
+) -> list[int]:
+    """Keep the earliest clearing from each group of repetitive prose."""
+
+    selected: list[int] = []
+    for index in indices:
+        if not duplicate_fields(
+            clearings,
+            [*selected, index],
+            threshold=threshold,
+        ).get(index):
+            selected.append(index)
+    return selected