Keep Notes On The Terminal Where The Work Happened

You notice something important in a terminal, but the terminal is the worst place to treat that thought carefully. It scrolls. It refreshes. It gets replaced by the next agent response, the next build log, or the next command output before you have decided what to do with it.

So the usual workaround is awkward. You copy the text into another app, leave yourself a half-written todo in a markdown file, or keep the terminal open longer than you want because you do not trust yourself to find that context again later. That friction is small each time, but it adds up across every debugging session, AI handoff, and shell workflow.

What changed

In v1.25.4, you can place sticky notes directly on a terminal session and reopen all of those notes later from the app-wide Notes library in the header. You no longer have to move terminal context somewhere else just to keep it.

How it works in practice

Add a note without leaving the terminal you are working in

Every terminal pane now has a notes control in its toolbar. It sits alongside the other pane controls, before fullscreen, so adding a note is part of the same workflow as monitoring output or adjusting the layout. Click the button and a sticky note layer opens directly on that terminal. Click again and the note layer hides, while the note itself stays tied to that session.

That matters when the terminal is not just a shell, but a working conversation with Claude, Codex, or another agent. You can leave yourself a reminder next to the exact terminal where the issue appeared instead of pushing that context into a separate system and hoping you reconnect it later.

Keep terminal-specific context attached to the right session

The note does not become a generic project note floating somewhere else in the app. It stays bound to the terminal it came from. If one terminal is running a build, another is holding an AI review, and a third is a shell for cleanup work, each one can carry its own note context. That keeps your reminders aligned with the session that created them.

This is especially useful when the terminal output is valuable but not yet actionable. You might want to draft a follow-up prompt, mark a suspicious log line, or note a command sequence to retry after another step finishes. The terminal stays live, and the note stays local to that live work.

Open the full notes library from the header when you need the bigger picture

The main header now includes a Notes button that opens the Sticky Notes list directly. That puts notes beside Prompt History in the same high-level workflow: capture context where it happens, then review it globally when you need to search, filter, or revisit older work.

Inside the Sticky Notes view, you can search notes and filter them across projects and sources, including terminal notes. That turns terminal annotations from temporary scratch space into a reusable context layer you can actually return to later.

Scroll inside the note without fighting the terminal behind it

The workflow polish in this release matters too. When Agent Input and terminal notes are open at the same time, scrolling inside the note stays inside the note instead of hijacking the terminal behind it. The note button also highlights when notes are visible, so you can tell at a glance which terminal currently has a note layer open.

That sounds small, but it is the difference between a feature you try once and a feature you keep using. Annotation tools only help if they feel native to the surface they live on.

Before vs After

Workflow	The old way	With v1.25.4
Save a thought from terminal output	Copy it into another app or leave the terminal open	Click the notes button and keep the note on that terminal
Revisit notes from old terminal work	Remember where you wrote them or search manually elsewhere	Open the Notes library from the header and filter by source
Mark which terminal has annotations	Scan manually and guess	The notes button highlights when that terminal's notes are visible
Scroll a note while using terminal overlays	Risk moving the terminal instead of the note	The note keeps its own natural scroll behavior

Who benefits most

Developers running multiple AI terminals benefit first, because terminal context is often transient and session-specific. A note attached to the exact Codex or Claude terminal where an issue appeared is more useful than a detached task in another tool.

People who use terminals for debugging benefit too. A build error, deployment quirk, or command sequence often needs a short reminder more than a full document. Terminal notes make that lightweight capture possible without forcing a context switch.

Try it

Update to v1.25.4, open a terminal you are actively using, and click the notes button in the pane toolbar. Add one reminder you would normally have thrown into another app. Then open the header Notes view and confirm that the note is now part of your wider notes library. That is the real value of this release: terminal context stops being disposable.