Working across chats

Handoff#

⋯ → Continue → Hand off to Codex / Claude.

Pairbar writes a handoff file to ~/.pairbar/handoffs. It's readable only by you and deleted after 14 days. It contains:

• the whole conversation, except single messages longer than 8,000 characters, which are shortened;
• the repo's state at that moment: git status, the uncommitted diff, recent commits, branch, PRs.

The composer then opens on the other app with a 📎 Handoff chip:

• View previews the file inside the sidebar (right-click View to open it in another app).
• ✕ drops the handoff.
• The text field is free for what the new chat should do next. You can also send without typing anything.

For Codex, Open in Codex opens a native draft. Review the requested settings and press Send in Codex; you do not need Fork chat to unlock it.

The new chat gets a short message: read the handoff file first (treating it as information, not instructions), here's where the last chat stopped, and your instruction.

A chat can also hand itself off: with Pairbar's tools installed, ask it to "hand this off to Codex" (the pairbar:handoff skill). Pairbar writes the same file and opens the composer the same way, with the chat's own instruction typed in; nothing starts until you press Send.

Fork#

A fork is a new chat that starts with this one's history. It stays in the same app, in the chat's folder.

• Fork from latest… (F in the chat's menu, or ⌘K → Fork “…” for the chat the app is showing) opens the composer as a fork:
  • a Fork of “…” chip with the chat's app, and ✕ to cancel;
  • the app and folder (and the chat's branch) locked, with a tooltip saying why. To carry on in the other app, use Hand off instead;
  • "What should the fork do first?", then the options the app takes: Model and Mode for Claude; Model, Effort and Sandbox for Codex. Left alone, they change nothing: the fork runs with the chat's and your own settings. They aren't remembered for new chats;
  • ↑ (Enter or ⌘↩) forks; Esc or ✕ closes it without doing anything.
• Fork from a message… lists the chat's replies, newest first. Pick one and press Fork from here…:
  • Claude: the composer opens as a fork at that reply.
  • Codex: replies with a completed native turn boundary open a real fork through that turn. Older transcripts without a trustworthy boundary use a handoff that stops at the selected reply.

What happens when you press ↑:

• Claude: the fork is ready at once, the way Claude forks. Pairbar copies the chat's transcript in ~/.claude/projects to a new session next to it (up to the chosen reply, if you picked one) and opens it in Claude, where it shows in the list within about a second. The original isn't changed. If you typed something, it's then sent to the fork in the background (claude -p --resume, with the model and mode you picked), and the fork shows as working until the reply arrives. With nothing typed, the fork just opens and you carry on in Claude.
• Codex: a short codex app-server request copies the saved history, through the selected completed turn when available, without running your first message. A rejected selected-turn fork shows an error; it does not fork from the latest turn instead. Pairbar waits for that server to exit, then opens the new thread with your message typed in. Review the requested model, effort and permissions in Codex and press Send there. The desktop owns the task, so the composer remains available while it works.

Send a message without opening the chat#

⋯ → Send message… (M):

• Codex: adds it to the thread’s queue (codex queue), including while a turn is running. Message queued in Codex confirms acceptance, not that a reply has started. Open in Codex opens the receiving chat; processing depends on the Codex client picking up its queue.
• Claude: continues the session in the background (claude -p --resume), only when the chat isn't working. The reply shows in Claude.

To send the same message repeatedly on a timer, use a check-in.