May 9th Build Progress

May 9 was the World Bible day.

The work started with Canon Builder, but the real product lesson was bigger than a renamed screen.

Canon intake should feel like building the World Bible.

Not asking permission from Forge.

Not borrowing space from a writing session.

Not turning a writer’s truth into a procedural ticket before the system has even understood it.

The core model became:

Create Canon collects the writer’s truth.
Saved Entries hold drafts and review states.
Format Entry makes the draft readable and searchable.
Gideon questions come after intake.
Promotion to repo canon stays separate.
Scene writing should not hijack canon building.

That is the contract.

The old Candidate Inbox name was too passive.

Too procedural.
Too much like a waiting room.

So the page became Canon Builder.

That language matters. A writer is not dropping scraps into an inbox. A writer is shaping the source of truth for the story world.

The language moved with it:

Candidate Inbox became Canon Builder.
Entry Intake moved toward Create Canon.
Character Turn became Character / Crew.
Clean For Forge became Clean Entry.
Send To Forge became Format Entry.

The product direction got clearer immediately:

The writer gives canon truth.
Gideon formats, organizes, and asks useful follow-up questions.

Canon intake should not begin with validation.

It should begin with trust.

Forge still matters.
But Forge is not the first voice in canon intake.
The writer is.

The next problem was visual noise.

All saved entries were appearing in one long stack under the form. Even five entries felt crowded.

That was not going to scale.

The saved entries moved into the World Bible navigation.

Now the model is:

World Bible
Library
Canon Builder
Saved Entries

Clicking Canon Builder opens Create Canon.
Clicking a saved entry opens that entry.
Clicking Edit reopens the form for that entry.

That separation made the workspace feel less like a pile and more like a tool.

Saved entries now behave more like working canon drafts:

– one selected entry at a time
– highlighted sidebar state
– formatted draft visible on the page
– raw intake tucked away
– edit mode is intentional
– new entries become the selected entry

That sounds small.
It is not.

Focused surfaces are how complex creative systems stay usable.

The old intake form asked for a Forge Question.

That was wrong.

It asked the writer to do Gideon’s job before Gideon had done any reading.

The form was simplified toward the real inputs:

Entry title.
Entry type.
Status.
Why should this be canon?
Source / notes.

Then Gideon generates the missing questions.

That is the better order.

The writer names the truth.
Gideon notices what is missing.
The writer answers.
The draft improves.

The first Questions & Answers loop now works inside saved entries.

The busy version had one Save Answer / Update Draft pair per question.

That became one shared pair:

Save Answers.
Update Draft.

Much calmer.

Much closer to how someone would actually use the tool.

The first formatted drafts were too loose.

Metadata, profile prose, and Gideon questions blurred together.

So the draft shape tightened:

Gideon Filing stays compact.
Profile gets readable headers.
Questions move into the Q&A section.
Raw intake collapses into a drawer.

The entry should feel like a canon draft, not a database row.

We also fixed a markdown cleanup issue where headings and body text were getting stuck on the same line.

Core Identity Bram Pike is…

became:

Core Identity

Bram Pike is…

That one formatting fix changed the whole feeling of the page.

The formatted draft drawers were also corrected:

– closed by default
– one opens at a time
– opening one does not open all
– closing one keeps it closed

These are small trust details.

A workspace that cannot keep drawers closed when asked is not ready to manage a world bible.

The biggest trust bug of the day was a save collision.

Callum Thorne was not saved correctly.

The app had an over-eager Bloody Gull Boys normalizer. If a candidate mentioned The Bloody Gull Boys, the app treated the whole entry as The Bloody Gull Boys.

That swallowed Callum into the band entry.

It also reverted The Bloody Gull Boys from Reviewed back to Needs Forge.

The fix was narrower and safer:

The app only treats the title as The Bloody Gull Boys if the actual title is The Bloody Gull Boys.
Changing the title while editing creates a new candidate instead of overwriting the wrong one.
Callum was restored as his own candidate.
The Bloody Gull Boys was restored as Reviewed.

That is the kind of bug that proves why canon tooling needs careful identity rules.

The Canon Builder now contains entries for:

Callum Thorne.
Bram Pike.
Finnian Bell.
Toby Marlowe.
The Bloody Gull Boys.

The band members moved into Character / Crew.

That matters because they are crew first. Not a faction. Not a relic engine. Not a separate mystical category.

The canon direction became clear:

Callum, Bram, Finnian, and Toby belong as character files.

The Bloody Gull Boys belong primarily in shipboard oral culture.

They are a performance act, a crew culture signal, and a cover-noise mechanism.

Not a new mythology system.

The local canon repo was updated with a focused pass:

– oral tradition and song
– Bloody Gull fleet context
– Jeb Blackwater
– Old Red
– Gus Maddox
– Stumpy Pete

Existing characters did not need broad rewrites.

They needed relationship-aware links to the band.

The EP201 relic transfer note also got clarified:

Old Red dies in EP108.
The Tuning Core cracks during the Red death arc.
Bone Dice and Tuning Core fully become part of the Bloody Gull in EP201.
The ship carries that transferred relic state forward.

Small canon detail.

Big continuity consequence.

The World Bible reader had been too raw.

It showed markdown and frontmatter like a file browser.

That changed.

Canon files now render as formatted pages. Frontmatter is hidden. Headings render as headings. Lists render as lists. Inline code is readable. Profile bodies use the available width.

Local editing was added too:

Select World Bible file.
Click Edit.
Edit markdown locally.
Click Save.
Write back to the local Gideon repo.

This is not a full promotion system yet.

It is the beginning of a clean local editing workflow.

The layout got quieter:

– module cards left the main page
– Library moved into the sidebar
– Canon Builder and Saved Entries became sidebar peers
– file drawers got compact
– closed drawers stay small
– the reader fills the right column better

That moved World Bible away from dashboard clutter and toward workspace clarity.

The second major product move was separating Writing Session from Forge.

Writing Session is where changes are discussed, drafted, revised, and applied.

Forge is where material is validated, audited, and turned into repair targets.

That distinction had been blurry.

Writing Session was widened and refocused.

The visible active-scene controls now point toward:

Discuss.
Edit.
Chart.
Story 1.
Story 2.
Send to Forge.
View Card.

Canon, Character, Voice, and Final moved out of the visible Writing Session surface.

Those passes belong to Forge.

Forge became the validation handoff page:

T3 for canon validation.
T4 for character consequence.
T5 for voice and format.
T6 for final polish and seal readiness.

Writing Session can send material to Forge.
Forge can send output back to Writing Session.

But Forge does not own the scene.

Forge prepares the judgment.

Forge handoffs now carry a clearer validation packet.

The packet tells Forge:

Do not auto-edit scene text.
Return validation, audit findings, repair targets, and suggested changes.
Full scene rewrites are out of bounds unless explicitly requested.
Approved changes are discussed and applied in Writing Session.

That should reduce accidental rewrites and keep Forge focused on pass logic.

Forge output sent back to Writing Session is now treated as a discussion packet.

Approve Scene stays disabled until Writing Session produces an intentional Discuss or Edit output.

That keeps approval tied to implementation.

Not automatic validation.

The Forge UI also changed shape.

It moved from a two-column utility console into a wider workspace shell:

Forge Result.
Forge Composer.
Episode Source Board.

Now it feels more like Writing Session:

– output above
– composer below
– primary action at the lower right
– copy, send, and save actions grouped with the workflow

This is the first layout pass.

The next real test is EP203_A01_S01 through T4.

By the end of May 9, Gideon had a cleaner product architecture:

Canon Builder gathers truth.
Questions clarify truth.
World Bible reads and edits canon.
Forge validates and packages judgment.
Writing Session discusses, revises, and applies changes.

That is the room system.

The workflow now feels closer to:

Draft truth in Canon Builder.
Clarify it through Q&A.
Promote intentionally into repo canon.
Read and edit repo canon in World Bible.
Validate scene work in Forge.
Bring judgment back to Writing Session.
Let the writer decide what changes.

That is the important part.

The writer decides.

There are still areas that need care:

– Promote to World Bible needs explicit approval.
– Candidate-to-repo linkage needs tracking after promotion.
– World Bible edits need clearer save feedback and eventually diff preview.
– Forge should remain optional for simple writer-approved canon intake.
– Forge must not produce full scene rewrites unless explicitly asked.
– Source Board and Forge need a real EP203_A01_S01 test.
– Writing Session should stay the place where changes are argued with and applied.

The next test should be practical:

Open EP203_A01_S01.
Send it to Forge.
Run T4.
Check whether Forge produces validation, repair targets, and suggested changes without taking over the scene.
Send the output back to Writing Session.
Discuss or edit from there.

That will tell us what the new room system actually feels like under real story pressure.