57loop — Context Translator for Codex

Real wrapped session — conversation, Before/Current Actual, and plain-language Context in the packaged macOS app.
Human agency — a real Codex network-command approval was declined, so the command did not run.
Causal replay — a human Change produced the next same-thread Actual and survives restart.

Inspiration

Codex could build faster than I could follow. Plans, diffs, terminal output and test results arrived in expert language, and I realized that I was often approving work without understanding the changing context. The bottleneck was not model intelligence or my lack of technical vocabulary. It was the size and shape of the information I had to process.

57loop is designed for people who need to participate meaningfully in AI coding without becoming professional developers first. It reduces each coding turn to a visible change, a plain-language explanation and one bounded decision.

What it does

57loop is a local-first Codex client with a Context Translator built around the conversation.

The user selects a real project and starts or resumes a Codex thread inside 57loop.
The same screen keeps the immutable Before and the latest observed Current Actual visible together.
Completed file-change evidence becomes an Actual checkpoint; an assistant message or command start alone never does.
The Context Translator explains what changed, why it happened now, the likely effect, what is still unverified and what decision is needed next.
The user can ask, change direction, approve or decline an action, steer the active turn or interrupt it without leaving the product.
Replay links the user's intervention to the next same-thread Actual, so the result is a causal sequence rather than a decorative progress log.
English and Korean are product settings; the submitted judge path is English.

The browser build is explicitly labeled DEMO. The packaged macOS app is the real wrapped-runtime path.

How I built it

The frontend uses Next.js, React and TypeScript for the Conversation Dock, Before/Current Actual theater, Context Translator and causal replay. A Tauri/Rust host starts the official local codex app-server over stdio JSON-RPC, binds one 57loop session to one project root and Codex thread, and persists messages, activity, approvals, actual checkpoints and context packets locally.

The runtime enforces a truth boundary: model text is conversation, an approval request is pending action, and only completed same-thread file-change evidence can be promoted to Current Actual. The existing local ledger and observer assets were preserved as historical evidence while the product was meaningfully extended from an external sidecar into a client that owns the Codex conversation.

How I used Codex and GPT-5.6

GPT-5.6 in Codex was the primary implementation partner. I made the product decisions: solve blind approval, move the conversation inside 57loop, replace predicted After with sequential observed Actuals, keep Before and Current Actual together, and require one human decision plus causal proof.

Codex turned those decisions into versioned product, experience, architecture and verification contracts. It implemented the React experience and Tauri/Rust app-server host, added routing and truth-boundary tests, built the macOS app and ran the real frontend. In the packaged app, Codex completed an in-app response, created a proof file, exposed a real network-command approval that I declined, accepted a same-thread change request and produced a second causal Actual. Restart recovery then restored the bound thread, messages, Actuals, Context Packets and replay.

Primary Codex Session ID: 019f7232-9ea2-7b12-b9f5-331fd1a441ff

Challenges

The hardest problem was preserving truth across conversation, execution and UI. If intent looks like an actual result, the product creates false confidence. If a pending approval looks applied, the user loses agency. If activity from another thread can appear in the current session, the explanation is unsafe. We therefore separated messages, turn activity, approvals, technical evidence, context packets and actual scenes, then projected only matching project/thread evidence into the active theater.

Accomplishments

A real in-app Codex conversation bound to one project and thread.
Simultaneous Before and Current Actual at 1200×900, with a fixed compact mode.
Plain-language Context Packets that explicitly retain uncertainty.
A real approval decline that prevented the requested network command.
A human Change followed by a second same-thread Actual with causal replay.
Restart-safe session, message, Actual and replay recovery.
42 passing Rust tests with one provider-only test ignored, 26 web tests and 15 CLI tests.
A public, no-account browser demo that never pretends to be the live runtime.

What I learned

The human bottleneck in agentic coding is often contextual participation, not raw intelligence. Simpler words help, but the stronger intervention is structural: show the change in sequence, keep the baseline visible, expose uncertainty, reduce the next decision and prove whether that decision changed the next result.

What's next

After submission, I will run a five-user comprehension test and measure three-second orientation, thirty-second explanation, actual-versus-intent recognition and decision confidence. The next engineering gate is two-project live isolation. Cloud collaboration, billing, broad IDE support and decorative gamification stay out until those two gates pass.