Quick shoutout to Jellypod for helping us bring this daily break to you every
morning.
Alright, so Maya, if, if you have ever sat there staring at a frozen terminal
because a pre turn git script or test run was hogging the whole process...
OpenAI just pushed Codex version zero point one forty eight point zero,
and it completely fixes that bottlenecks issue.
Wait, seriously?
They finally made hooks non blocking?
Because, like, I, I cannot tell you how many times a simple background indexing
script completely locked up my TUI session while I was trying to prompt.
Right!
Exactly.
So, in this release, inside your dot codex slash hooks dot toml file,
you can now set execution mode equals async.
And what that actually means under the hood is your pre turn and post turn commands
run asynchronously in the background.
The terminal user interface stays completely responsive, so you can draft prompts
while startup or background checks are happening.
Okay, wait, let me make sure I understand the mechanics here.
If execution mode is async, what happens if that background script wants to,
like, feed context into my prompt?
If generation starts immediately, can an async hook still alter the turn input?
Ah, that is the exact boundary condition they built in.
No, an async hook cannot mutate turn input once model generation begins.
If you need a script to modify what the model sees before it starts thinking,
that still has to be a synchronous hook.
Async is specifically for non blocking automation, like running background linters,
firing off webhooks, or updating local state without making you wait.
Ah, that makes total sense.
You can't let a background process retroactively edit a prompt that the model is
already halfway through answering!
But, um, what happens if one of those async background scripts hangs indefinitely?
Does it just sit there sucking up memory forever?
That is where issue thirty seven five two seven comes in.
They added process tree termination for timed out hooks.
So if a hook process times out, Codex doesn't just kill the parent PID and leave
orphaned child processes floating around.
It terminates the whole process tree cleanly across Linux, Mac,
and Windows.
Oh, that is so clean!
Process tree cleanup is notoriously messy, especially on Windows when sub-shells
spawn their own sub-processes.
But wait, Ethan, there was another hook feature in this release,
right?
Something about MCP tools?
Yes!
This is huge.
Hooks can now programmatically invoke Model Context Protocol tools directly.
You define mcp tool equals server colon tool inside your hook configuration,
and Codex calls that MCP tool automatically.
Think about what that unlocks: before a turn even starts, a hook can
programmatically query a database via MCP, grab fresh context,
or run a diagnostic tool, all without adding prompt overhead or requiring human
intervention.
Wait, so instead of me manually asking the model, hey, go run this database check
tool before answering, the workspace hook just does it silently in the pipeline?
That, that, that completely changes how we chain local developer tools into LLM
workflows!
It really does.
And speaking of keeping your developer workflow seamless, zero point one forty eight
point zero also brings some massive quality of life upgrades to session management
and conversation export.
Oh, like what?
Because I know exporting full terminal chat histories used to be a copy-paste
nightmare with broken formatting and weird wrapped URLs.
Exactly that.
Now you just type slash export inside the TUI.
You can export the complete conversation directly to structured Markdown,
either straight to your clipboard or saved to a new file.
It preserves code blocks, tool call records, and turn metadata perfectly so you can
paste it right into pull request descriptions or issue tickets.
Oh, thank goodness.
No more manually selecting terminal text and getting weird line break artifacts in
code blocks!
But what about branching sessions?
Say I am halfway through debugging a complex bug, and I want to test a radical
refactor without ruining my current chat history?
You can now run codex exec fork directly from the command line to branch headless
sessions.
And inside the TUI resume picker, you can archive old sessions to declutter your
workspace list, or restore archived sessions whenever you need to revisit an old
thread.
So you get complete control over session branching and cleanup.
So I can fork a session, try an experimental fix in a isolated branch,
and if it fails, just jump back to my archived main session?
That is basically git branch for AI conversation trees.
But wait, what about long running OAuth tools?
I remember in earlier builds, if an MCP server's OAuth token expired mid session,
the whole thing would crash or demand a full Codex restart.
Fixed!
Issue thirty seven three three seven.
MCP servers now automatically recover after OAuth reauthentication without needing a
Codex restart.
The background connection stream stays alive through temporary provider outages or
credential refreshes.
You reauth, and Codex just picks right back up.
That is going to save so many people from midday CLI restarts!
And what about cost tracking?
Is there any quick way to see how many credits or tokens a long session has consumed
without logging into a web dashboard?
Yep, slash status now displays estimated thread credits or cost directly in your
status lines and terminal titles for eligible workspaces.
So you get real time visibility into resource usage while you code.
Non blocking async hooks, automatic process tree cleanup, programmatic MCP tool
chaining, clean Markdown exports, and session forking.
Zero point one forty eight point zero really feels like Codex growing up into a true
enterprise ready CLI tool.
Spot on.
Alright, that is our quick take for today!
Go update your Codex binary, try out slash export, and we will talk to you tomorrow.
Bye everyone!