I reopened the repair contract before I touched the code.
By then I knew better than to trust myself to remember the boundaries once implementation started. The closer I got to a fix, the easier it was to convince myself that one more cleanup was part of the same job.
“Read the allowed scope back to me,” I typed to ChatGPT.
It answered with the rule we had already locked.
“Resolve the current approved continuation authority first. Then permit boundary selection only within that resolved authority. Preserve approval semantics, rollback history, and unrelated persistence behavior unless the repair exposes a separate failure.”
I left the sentence visible at the top of the screen.
“That is the box.”
Then ChatGPT immediately started trying to widen it.
“Since we are already in the continuity flow, we could normalize the recovery path and persistence handoff so every entry route constructs authority the same way.”
“Deferred.”
I opened the contract and split the implementation notes into two sections.
Required now.
Deferred unless the repair exposed a separate failure.
The required section stayed short.
We needed to find the point where Story Architect began comparing approved records and move authority resolution ahead of it.
Everything else had to justify itself against that change.
I traced the resume flow with ChatGPT one step at a time.
Approved records came in.
The existing selector filtered and ranked them.
Only after that did the system try to work out which returned boundary was supposed to count as current.
That order was the thing we were changing.
“Where does authority resolution have to happen if we follow the contract literally?” I typed.
“Before candidate selection begins.”
I marked that as the insertion point.
We moved the authority decision ahead of the selector.
The selector would no longer start by asking which approved record looked most eligible.
It would receive the state that had already been established as current and choose only within that authority.
ChatGPT suggested cleaning up the selector ranking while we were there.
“The ranking rules still have some historical assumptions. We could simplify them now that authority constrains the candidate set.”
“No. If ranking is wrong after authority is resolved, it can fail its own test.”
I wanted the code change to be as boring as the contract, so we left ranking, recency behavior, rollback-specific logic, and persistence cleanup untouched.
The only architectural change was the order: resolve current authority before selection, then select inside the resolved authority.
I made the change.
It was larger than the eligibility patch but smaller than the redesign ChatGPT kept trying to offer me.
The architecture moved one decision ahead of another.
That was the whole point.
Then I pulled in the two regression histories before running anything.
The first was ordinary forward progress, where newer approved work was current.
The second was rollback, where an older approved state had been deliberately restored as current while newer historical approvals remained in the project.
“Wire both into the test now,” I typed. “Not after the first one passes.”
ChatGPT added both histories to the harness.
I wanted them there together because I did not want the first green result to change how generous I became with the second.
Above them, I pasted the release requirement again.
After a user approves work, leaves, and returns, Story Architect must restore the current approved continuation authority.
Then I added the pass condition we had already written.
A changed result is not a pass unless it is the correct current authority.
ChatGPT read it back.
“The resolved authority must survive leave and return, and boundary selection must occur only after that authority is established.”
I kept that line too.
The whole test setup was now visible before execution: the code change, the two contradictory histories, the fixed requirement, the exclusions, and the deferred work sitting off to the side where it belonged.
For the first time since the selector patch failed, the repair felt both larger and more controlled.
That combination mattered.
I had stopped trying to make the problem tiny enough to feel safe.
I was making the repair bounded enough to prove.
ChatGPT looked over the change one more time and reminded me that fresh-session reconstruction still had not been tested. If the warm-session repair passed but a full restart rebuilt the wrong authority, launch would remain blocked.
I moved the reminder into Deferred without changing the current harness.
The repair had not earned that question yet.
I saved the implementation.
Nothing had passed or failed yet, but the authority-first rule was finally in code under the exact contract that had forced us to write it.
I reset the forward-progress regression.
Now the repair had to stop sounding right and start surviving tests.
I reset the forward-progress regression with the authority-first repair active and pulled the contract back onto the screen beside it.
This was the easier history.
Newer approved work was current. No rollback. No restored older state. No conflict between chronology and authority.
That made it useful and dangerous at the same time.
Useful because the expected result was clean.
Dangerous because recency and current authority pointed to the same place, which meant a bad rule could still look good.
“Run the test exactly as written,” I typed to ChatGPT. “And if it passes, do not tell me why until we inspect the trace.”
“Understood.”
I opened the current approved continuation point and verified it one more time.
This was the state the user had established as current.
I left Story Architect through the ordinary path.
Then I returned.
The project opened at the newer current continuation point.
ChatGPT answered instantly.
“Pass.”
“Maybe.”
I was not willing to give the result away that easily.
The same boundary could have been produced by the old recency shortcut. If the selector had simply preferred the newest valid approved record, this particular history would still land in the right place.
That would make the screen look repaired without proving the architecture had changed in the way the contract required.
“Show me the trace.”
ChatGPT opened the flow.
The first meaningful step was different now.
Before the selector compared any boundaries, Story Architect resolved the newer approved state as the current continuation authority.
Only after that did boundary selection begin.
The selector received a constrained authority context instead of a pool of approved records it had to interpret as peers.
“Do any older approved states still enter selection as equal candidates?” I typed.
“They do not. They remain valid historical records, but they are outside the resolved current authority and do not compete for continuation.”
That was the first answer of the repair that made me feel the architecture instead of merely reading it.
The older states had not been deleted.
They had not been made invalid.
They had not been hidden by a special-case filter.
They simply were not being asked to compete for a decision they no longer owned.
I looked at the returned boundary again.
Same result I wanted.
Different reason.
That distinction mattered more than the green test.
I asked ChatGPT to compare the trace against the release requirement we had written before implementation.
It read the requirement back first.
“After a user approves work, leaves, and returns, Story Architect must restore the current approved continuation authority.”
Then it matched the trace to the requirement.
“The current authority was established before boundary selection, survived the leave-and-return path, and constrained selection to that authority.”
I opened the pass condition beneath it.
A changed result is not a pass unless it is the correct current authority.
I still did not mark the regression green.
“Check whether any later ranking step can escape the resolved authority.”
ChatGPT inspected the remaining selection steps.
“No. Ranking occurs only inside the resolved authority. Recency can affect a choice within that authority if more than one boundary is eligible there, but it cannot select a boundary from another approved state.”
Recency was no longer pretending to answer which state was current.
It could do local work after that question had already been answered.
I went back to the original failure and compared the old mental model with the new one.
Before the repair, the selector had been handed approved history and expected to infer authority from record properties.
After the repair, authority arrived first and reduced the selector’s job to choosing inside the state that already owned continuation.
The trace was what made the result trustworthy.
“Now can I call it a pass?” ChatGPT asked.
I smiled despite myself.
“Yes.”
I marked the forward-progress regression green.
For once I let the word stand without immediately qualifying it.
The test had earned that much.
ChatGPT summarized the result.
“Forward progress passes under the authority-first repair.”
I left the sentence alone.
Then I opened the rollback regression beside it.
The green mark felt good, but it did not close the repair.
This history had newer and current pointing to the same state. The architecture now had to survive the history that had broken every shortcut before it.
Older had to be current.
Newer history had to remain present.
And the same authority-first rule had to hold without a rollback exception.
I kept the forward-progress trace open as the control and moved to the rollback case without changing the repair.
The first clean pass was finally real.
Now the repair had to prove that the success belonged to the rule and not to the convenience of the history.
By then I was tired enough that every good result felt personal.
I wanted to close my laptop, make dinner, come back the next morning, and trust the page waiting for me without replaying the last six hours in my head.
I kept picturing an ordinary morning after a long night of writing. Coffee beside the keyboard. A sentence still half alive in my memory. The quiet confidence that I could pick up where I had decided to stop.
If that confidence was misplaced, I knew what I would do first.
I would blame myself.
I would assume I had remembered wrong, changed my mind, or forgotten which pages I meant to keep working from. I could lose an hour following the wrong thread before I ever suspected the tool in front of me.
I knew what that hour would feel like. I would start by rereading a paragraph, then another, looking for the moment the story stopped matching what I remembered. I would scroll backward. I would open notes. I would wonder whether I had been more tired than I thought the night before. By the time I realized the page itself had moved me, I would already have spent energy distrusting my own memory.
And once that kind of doubt entered the room, it would follow me into the next choice too. I would hesitate before trusting the page, hesitate before closing the laptop, and wonder whether I had to keep my own private map just to stay safe.
That image stayed with me because it was so ordinary. There would be no alarm, no warning box, no spectacular crash. There would just be a person trying to return to their own work and quietly being placed somewhere they had not chosen.
I thought about the emotional cost of that more than the technical cost. I pictured myself rereading yesterday’s scene with my notes open beside it, checking the last choice I had made before I let myself type another line.
There was also something more personal in it than I wanted to admit. I had spent enough time correcting ChatGPT, correcting Story Architect, and correcting my own assumptions that I was tired of treating vigilance as part of the creative process. I wanted to be able to stop watching the machinery and go back to caring about the story.
For a minute I imagined what success would actually feel like outside this room. It would not feel like a trace turning green. It would feel boring. I would leave, come back, and continue. I would not notice the system because it had respected a choice I had already made.
That was what I wanted.
That was not the kind of friction I wanted to dismiss as technical. It would land in the most ordinary part of writing, the part where someone sits down and expects yesterday’s decision to still be there.
I did not want anyone using what I built to need suspicion as a survival skill.
So I went back to an earlier part of the manuscript and decided that was where I wanted to continue now.
Everything I had written afterward stayed exactly where it was. I was not erasing those pages or pretending they had never happened. I was only choosing my starting place.
I sat with the earlier pages on one side of the screen and the later pages on the other.
Both belonged to the story.
Only one was where I wanted to begin again.
“If I leave and come back,” I typed to ChatGPT, “which one should open?”
“The older one you just chose.”
I let my hands rest in my lap for a moment.
That answer was simple enough that a writer should never need to understand anything about the machinery underneath it.
I closed the story, waited a few seconds, and reopened it. The older version appeared, and I stayed still long enough to make sure I was not seeing what I wanted to see.
Relief arrived first, followed almost immediately by suspicion. I had learned not to trust a good-looking result just because I wanted it.
ChatGPT was already there.
“Pass.”
“Show me why.”
It walked me through what had happened in plain language first.
Story Architect had recognized the older version as the place I had chosen to continue before it looked for a page to reopen. The newer pages were still part of the project, but they never got the chance to overrule that choice.
Only after I understood that did I open the technical trace.
The authority-first step had resolved the deliberately restored older state as current before boundary selection began. The selector then stayed inside that resolved authority, so the newer historical approvals never entered as competing continuation candidates.
I read the trace slowly.
This was the history that had broken every shortcut.
Newest could not save us here because newest was wrong by design.
Validity could not save us because all the important states were valid.
A rollback-specific selector exception was not present.
The same architecture that had passed forward progress was now following the older state because older was the one that held authority.
I pulled the forward-progress trace beside it.
In that history, Story Architect had resolved the newer approved state as current.
In this one, it had resolved the restored older state as current.
The selector behaved the same way afterward in both cases.
I stopped scrolling and left the two traces beside each other.
“Compare both traces to the release requirement,” I typed.
ChatGPT read the requirement we had locked before implementation.
“After a user approves work, leaves, and returns, Story Architect must restore the current approved continuation authority.”
Then it compared the histories.
“Forward progress satisfies the requirement with newer as current. Rollback satisfies the same requirement with the restored older state as current. Neither pass depends on a selector exception that changes according to chronology.”
I left that response visible.
For most of the day, every improvement had come with an argument attached to it.
The first patch changed the returned boundary, but not to the right one.
The next idea worked only until rollback made newer and current disagree.
Every selector shortcut had needed some explanation for why this result was close enough or why the next exception would finish it.
This one did not need that kind of defense.
The two histories contradicted each other and the same rule survived both.
I marked the rollback regression green.
The forward-progress regression was already green beside it.
For the first time, I had two clean passes that were difficult in opposite directions.
ChatGPT summarized the result.
“The original warm-session continuity defect is fixed within the tested scope.”
I read the sentence twice.
Then I let it stand.
“Within the tested scope,” I typed.
“Yes.”
That qualifier did not weaken the result. It made it honest.
The repair had done exactly what the contract required in the environment we had actually tested.
Forward progress passed.
Rollback passed.
No recency shortcut overrode authority.
No rollback exception changed the selector rule.
The authority-first architecture had finally earned a success I did not have to talk myself into.
I looked at the launch status.
Blocked.
ChatGPT noticed too.
“The tested continuity defect is repaired. We can reopen launch.”
“Not yet.”
I opened the deferred section of the repair contract.
Fresh-session reconstruction was still sitting there.
Up to this point, current authority had been available inside a warm working session. The next case would remove that convenience completely.
When the session disappeared, Story Architect would have to reconstruct current authority from saved project state before the repaired selector could do anything useful with it.
I pointed at the untested fresh-session case and left the launch status blocked.
ChatGPT did not argue.
That felt new too.
Earlier in the day, it had treated every promising result as a reason to widen or close the problem. Now we had a result strong enough that neither of us needed to pretend it proved more than it did.
I left the two green regressions on the screen and opened a fresh-session test beneath them.
The emotional shape of the problem had changed.
I was not trying to discover whether the authority-first repair worked anymore.
It did, at least in the warm-session scope that had defeated every earlier patch.
Now I was protecting that success while asking one new question.
If the working session vanished and Story Architect had to rebuild authority from persisted state, would it reconstruct the same current state before the selector ran?
I saved the warm-session results before starting anything else.
Two green regressions.
One architecture repair worth preserving.
One deferred release question left.
Then I closed the working session completely.