May 13th Build Progress

May 13 was the import-workflow day.

The session started with a deceptively simple problem:

Gideon could build a strong Field Scene Card from a light outline, but when a full written scene came in, the workflow treated it like something else.

That was backwards.

A full draft should give Gideon more to read, not less.

The core product lesson:

Gideon needs one reliable scene-card builder that can read whatever the writer gives it.

A small outline.
A rough beat list.
A full scene draft.
A legacy tier stack from an older process.

The input can be light or heavy. The job is the same:

Sort the material into the Field Scene Card format, save the scene pack, and keep the writer moving.

The first failure showed up with EP201_A01S01.

The scene was already written. It had emotional shape, character pressure, relic behavior, dialogue snapshots, and scene exit logic.

But when it was imported through Add Scene, Gideon created the scene pack without creating the expected card.

Then, when the material was sent through Discuss / Chart, Gideon produced something closer to a useful analysis than the actual Field Scene Card format.

That made the problem clear:

The system was treating a full scene draft as a discussion object instead of as source material for a scene card.

The result was too interpretive.
Too loose.
Too far from the EP203 card format that already worked.

The first instinct was to ask where the Scene Card should live in the tier flow.

One option was to build it during T1 / Story 1 approval.

That made some sense structurally. Chart the Waters could be for discussion, emotional mapping, and outline development. T1 could lock the beats, who is in the scene, entry state, and exit state.

But importing an already-written scene needed a cleaner path.

The better answer was simpler:

Import Scene should save the scene pack and build the Field Scene Card immediately.

No active scene bar.
No tier buttons.
No Forge handoff.
No extra UI ceremony.

Just:

Paste the scene.
Create Scene Pack.
Build the card.
Show it in Episodes.

The import screen was stripped down to the work it actually needed to do.

The active scene controls were hidden.

The session attach controls were hidden.

The regular run/save-note behavior was hidden.

That left the writer with one obvious action:

Create Scene Pack.

In import mode, Create Scene Pack now does more than create the draft record.

It also builds the Field Scene Card from the imported material and saves the card to the source repo.

That matters because the scene card is not a later luxury. It is the memory structure Gideon uses to understand the scene.

This session also clarified how to handle scenes that came through the old Gideon GPT tier process.

Those imports may include:

– old tier labels
– audit cards
– emotional pulse notes
– dialogue redlines
– no-touch zones
– vault-path validation tables
– visual iconography
– relic notes
– full scene draft text

The product answer is not to make every future user understand that old language.

Most users will not have that stack.

The useful path is to let Gideon read the material as source context, pull what it can, and normalize it into the current Field Scene Card structure.

The old stack is not the product.

The current scene pack and current Field Scene Card are the product.

EP201 and EP202 already existed in the system, but they were not in the right format.

That created a trust problem in the Episode Library.

If the library contains outdated scene-card structures, the writer cannot tell whether a scene is current, imported correctly, or still carrying an old workflow shape.

So the outdated EP201 and EP202 material was removed from the database and from the Gideon source repo.

That cleared the way for clean imports using the new path.

No stale format.
No confusing duplicate.
No old card masquerading as current structure.

The first end-to-end test almost worked.

The button changed to:

Building Scene Card…

Then it returned to an approval state, but the scene did not appear in Episodes.

That was the right failure to catch.

It meant the import operation was building something, but the post-save flow was still behaving like a normal active-scene approval path instead of an import path.

The fix was to make import mode finish by refreshing the Episode Library and opening the saved scene from the library context.

That gave the import flow a real ending:

Create Scene Pack.
Build Field Scene Card.
Save to database.
Save to repo.
Refresh Episodes.
Show the imported scene where the writer expects it.

After import started working, the next test was Add Scene inside EP203.

The writer pasted a small outline:

A2S2 – The Lesson Disguised as Trust

Scene purpose.
Entry state.
Exit state.
Pressure.

The scene pack was created, but the generated card initially missed too much. It let the wrapper instruction become the Scene Pulse and left obvious labeled fields sitting unused.

That revealed the second half of the issue:

Gideon needed to treat labeled outline fields as privileged scene-card inputs.

Scene purpose should feed Scene Pulse and Captain’s Note.
Entry state should feed Scene Pulse and Scene Exit.
Exit state should feed Scene Pulse and Scene Exit.
Pressure should feed Scene Pulse, Emotional Role Map, and Threat logic.

The card builder had to read the writer’s small input with the same seriousness it reads a big draft.

The card builder was updated to extract labeled outline material directly.

That changed the behavior immediately.

With a light scene idea, Gideon could now pull:

– scene purpose
– entry state
– exit state
– core pressure
– likely location pressure
– emotional role map material
– missing inputs
– next workspace move

The strongest test was EP203_A02S03, Sophia Tests the House.

The input was still light, but the card became useful.

It recognized Sophia’s active investigation, the USS Cyclops as house / cage / archive, Benjamin’s pressure as architectural, the breach and faction material as possible evidence lanes, and the important distinction:

This is not Sophia tries to escape.

This is Sophia tests the house.

This was the bigger product turn.

The Field Scene Card should not depend on whether the writer starts with a full scene or a few lines.

The same structure should hold:

Scene Identity.
Scene Pulse.
Source Match Table.
Location.
Visual Iconography.
Primary Dialogue Snapshots.
Emotional Role Map.
Myth / Relic / Fracture Tags.
Threat / Antagonist Presence.
Scene Exit / Next Link.
Captain’s Note.
Missing Inputs.
Workspace Next Move.
Tier Stamps when present.

A heavy input should fill more of the card.

A light input should fill what it can and mark what is missing.

That is the right intelligence pattern for Gideon.

Not pretending the input is complete.
Not ignoring the useful parts.
Not inventing certainty.

Read what is there.
Sort it correctly.
Ask for what is missing.

Gideon now has a clearer scene intake model:

Import Scene is for already-written drafts and legacy scene stacks.

Add Scene is for new scene ideas, outlines, and beat sketches inside an episode.

Both paths create a scene pack.

Both paths build a Field Scene Card.

Both paths feed the same episode library structure.

And as the scene develops through Chart, Story 1, Story 2, and later tiers, the existing card can keep updating and refreshing without replacing the core workflow that already works.

That is the important distinction.

The fix was not to rebuild the whole tier system.

The fix was to give intake a clean front door.

Two commits marked the stable checkpoint:

SIGNAL-SALT-AI-APPS:
Add legacy scene stack import path

GIDEON-agent-pilot:
Remove outdated EP201 and EP202 materials

That split matters.

The app repo owns the workflow.

The Gideon source repo owns the story material.

Cleaning both sides kept the product and the canon workspace aligned.

A few things still need careful testing:

– Import Scene should always return the writer to the saved scene in Episodes.
– Add Scene should keep using labeled outline fields before falling back to generic inference.
– The Field Scene Card should stay in the current EP203-style format.
– Full drafts should produce richer cards, not looser analysis.
– Light outlines should mark missing inputs without acting helpless.
– Existing card refresh behavior across later tiers should remain untouched.
– EP201 / EP202 imports should be tested from clean source material after the stale versions are removed.
– The import UI should stay boring in the best way: paste, create, card.

The watch point is not complexity.

It is restraint.

The scene intake flow should not become another writing room.

It should be the door into the writing room.

The next useful tests are practical:

Import EP201 from the already-written draft.
Import EP202 from the old material.
Confirm both scenes appear in Episodes.
Confirm both cards use the Field Scene Card format.
Confirm later tier work refreshes the card without changing the intake model.
Keep testing Add Scene with light outlines inside EP203.

That is the right rhythm now.

Import what already exists.
Add what is still forming.
Let the card grow as the scene grows.

No extra ceremony.
No hidden mutation.
No lost scene card.