Skip to content

ormeggio

ormeggio is a Claude Code plugin for coming back. You leave sessions working and go away for a few days; they carry on until something stops them, and nothing stops them loudly. ormeggio reads how each one ended, restarts the ones that can carry on alone, and puts the questions that are waiting on you in one place. It is written in Python with no dependencies and licensed GPL-3.0.

Each of these happened on one machine in the autumn of 2026, more than once.

  • The usage limit. The turn ends with “You’ve hit your 5-hour limit” and the session sits there after the limit resets.
  • A login that expires. Every session fails at once with a 401, and stays failed after you log in again.
  • A battery that runs out. A tool call never returns, and the restart empties /private/tmp, scratchpads included.
  • An app that freezes. Twenty sessions at once kept the desktop app’s main thread busy for hours, and every tool call waited ten minutes for it.
  • Background agents reported as stopped, with nobody there to answer.

And the one that is not a failure: a session that finished with a question for you.

Terminal window
claude plugin marketplace add nerln/ormeggio && claude plugin install ormeggio@ormeggio

Or load it for a single session:

Terminal window
git clone https://github.com/nerln/ormeggio.git
claude --plugin-dir ./ormeggio

The only dependency is Python 3; the one macOS ships is enough. Context cost is about 173 tokens per session, which is the skill announcing that it exists, and about 1,800 when it runs. That number comes from claude plugin details ormeggio@ormeggio.

Nothing to do until you come back. Your first message after a pause longer than your threshold gets one paragraph from the hook: how long you were away, whether the machine restarted, which sessions stalled and why, which ones are waiting on you. Claude offers to run /ormeggio; say yes and it:

  • restarts the stalled sessions with a message to check what is already on disk and not start anything twice, at most twelve at once and only with 30% of memory free, through the desktop app’s session tools or claude -p --resume in a terminal;
  • holds the ones stopped by a usage limit while the limit is still used up;
  • lists every open question, numbered, with a link to its session, so one reply from you restarts all of them.

A hook on every message you send. It reads one small file and stays silent, unless the pause before your message is longer than your threshold. Only your own messages count: the hook also fires for background notifications, messages from other sessions, scheduled runs and claude -p scripts, so it looks each prompt up in the transcript, where Claude Code records who sent it.

A hook on failed turns. When a turn ends on an API error, Claude Code says which one, and ormeggio keeps the line, so a usage limit or an expired login is known later instead of guessed.

A skill that classifies each session from the end of its transcript (interrupted and why, finished with a question, finished, stopped by you, still working) and does the resume.

The threshold is measured from your own transcripts. For every day, take the longest pause between two of your messages; on three days out of four it stays under some length, and ormeggio waits a quarter longer than that. On the machine it was built on that gave 22 hours, the same on 30, 60 and 120 days of history.

It does not resume a session you stopped yourself, an archived or scheduled one, or one that stopped on a request the API refused: those go in the list for you. It does not answer the questions sessions left for you, and it does not restart a frozen desktop app, because closing the app ends every session inside it.

It reads transcripts and its own state, writes only to ~/.claude/ormeggio, and sends nothing over the network.

Terminal window
python3 tools/prova.py

Ninety checks, about fifteen seconds, against a throwaway Claude home: a transcript written by hand for every way a session can stop, a fake desktop app index, a fake clock and boot time, and a fake claude binary for the terminal runner, which must never run more than its limit at once. Then a live run: loaded into a real session with the clock set three days ahead, the first reply offered the resume, and the next message got nothing from the hook.

© 2026 Eugenio Giuseppe Nerelli