tuiboard 0.11.0 → 0.13.0

package/.tuiboard/config.example.yaml

@@ -43,13 +43,36 @@ archive_column: Archive
 # zones:
 #   planner: on      # Today/Tomorrow cross-board panel        (F1)
 #   agenda: on       # 24h agenda + calendar overlay           (F2)
-#   agents: on       # live Claude Code session view           (F3)
+#   agents: on       # live agent sessions view                (F3)
 
-# Optional: override what Enter does in the Agents zone ("open the selected
-# Claude Code session"). An argv array — the tokens {cwd} and {sessionId} are
+# Enter in the Agents zone opens the selected session in a new tab/window of
+# the terminal tuiboard runs in, detected automatically: tmux, herdr, WezTerm,
+# Windows Terminal, Ghostty — else the OS default (Linux: xdg-terminal-exec,
+# Windows: a new PowerShell window, macOS: Terminal.app). If nothing works, the
+# resume command is copied to the clipboard instead. Force one when detection
+# guesses wrong (e.g. a multiplexer env var leaking into another terminal):
+# resume_terminal: auto   # tmux | herdr | wezterm | windows-terminal | ghostty
+#                         # | xdg-terminal-exec | windows-console | macos-terminal
+#
+# The session runs in your shell, which stays open when the agent exits.
+# `auto` = the shell you started tuiboard from: on Windows Git Bash, Nushell or
+# PowerShell (pwsh, else powershell); elsewhere your $SHELL. Force one with:
+# resume_shell: auto      # bash | zsh | fish | nu | pwsh | powershell | cmd
+#
+# Agent status symbols, the same as herdr's: × waiting for you, ◐ working,
+# ✓ done, ○ idle, · closed (△ = turn stopped updating). Or colored dots:
+# status_indicators: symbols   # symbols (default) | dots
+#
+# Enter not doing what you expect? From the directory you run tuiboard in (in a
+# checkout of the repo): `bun run agents:open <session-id-prefix> --dry-run`
+# prints the detected terminal, shell and exact command; the `o` detail of a
+# session also shows the full result of its last Enter.
+
+# Optional: replace that with your own launcher script. An argv array — the tokens {cwd}, {sessionId} and {resume}
+# (the agent's own resume command, e.g. `claude --resume <sessionId>`) are
 # substituted, then it's run directly (no shell). Point it at your own script
-# to spawn a custom terminal layout. When omitted, tuiboard just opens a new
-# WezTerm tab and runs `claude --resume <sessionId>`.
+# to spawn a custom terminal layout. Takes precedence over resume_terminal —
+# remove it to get the automatic behavior above.
 #
 # The first element must be a DIRECTLY EXECUTABLE program — a real binary on
 # PATH or an absolute path. It is NOT run through a shell, so shell builtins
@@ -65,11 +88,12 @@ archive_column: Archive
 # Optional: the command copied to your clipboard by `c` in the Agents zone — one
 # paste that cd's into the session's directory and resumes it, for when you want
 # to open the session yourself in a new tab/pane anywhere (no WezTerm needed).
-# The tokens {cwd} and {sessionId} are substituted. It's a plain string, so use
-# whatever chaining your shell wants. Default (works in bash/zsh/pwsh/cmd):
-#   copy_resume_command: 'cd "{cwd}" && claude --resume {sessionId}'
+# The tokens {cwd}, {sessionId} and {resume} (the agent's own resume command,
+# e.g. `claude --resume <sessionId>`) are substituted. It's a plain string, so
+# use whatever chaining your shell wants. Default (works in bash/zsh/pwsh/cmd):
+#   copy_resume_command: 'cd "{cwd}" && {resume}'
 # Nushell users typically want `;` instead of `&&`:
-# copy_resume_command: 'cd "{cwd}"; claude --resume {sessionId}'
+# copy_resume_command: 'cd "{cwd}"; {resume}'
 
 # Optional: overlay read-only calendar events on the Agenda (the 24h timeline).
 # Connect a provider with `tuiboard calendar-setup google` / `... microsoft`,

package/CHANGELOG.md

@@ -5,6 +5,130 @@ All notable changes to **tuiboard** are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [0.13.0] - 2026-09-17
+
+tuiboard and [herdr](https://herdr.dev) now work as one: the Agents zone shows
+herdr's live state for every session open there, speaks herdr's status
+symbols, and `H` jumps to a session in herdr or resumes it in the right
+workspace. Plus fixes found using it all day on Windows.
+
+### Added
+- **Live agent state from herdr** (#37). When herdr is running, tuiboard polls
+  `herdr api snapshot` and links every pane running Claude Code, Codex,
+  OpenCode or Pi to its session — by the session id/file herdr reports (with
+  herdr's agent integrations installed), else by agent and directory. Those
+  sessions take herdr's state, including two new ones: **waiting for you** and
+  **done**; idle Codex/OpenCode/Pi sessions become visible, and long Claude
+  turns no longer show as stale (#22). Zoomed cards and the `o` detail show the
+  herdr workspace and tab.
+- **herdr's status symbols** — `×` waiting, `◐` working, `✓` done, `○` idle,
+  `·` closed (tuiboard's own `△` for stale) — are the default for everyone, so
+  both tools read the same; `status_indicators: dots` keeps colored dots.
+- **`H` opens sessions in herdr** (#38): focuses the pane a session is open
+  in, or resumes it in herdr — a new tab named after the session, in the
+  workspace that already holds that directory (else one named like the
+  folder, else the focused one). **Enter** on a session already open in herdr
+  focuses it instead of starting a second copy.
+- **Omarchy bar widget in the repo** (#27): `omarchy-plugin/` — an
+  overdue/today badge and a Today/Tomorrow panel (done, undone, defer, open
+  tuiboard) built on `tuiboard summary` / `tuiboard task`, installed with
+  `omarchy-plugin/install.sh`. Repo only, not part of the npm package.
+
+### Changed
+- **Agent sessions are sorted by most recent activity** (#43), newest first,
+  instead of by status first — a session used 40 seconds ago no longer sits
+  below ones idle in herdr for hours. Status only breaks ties; archived
+  sessions stay at the bottom.
+- Launch steps for Enter and `H` run asynchronously: a slow start (cold
+  PowerShell, an agent booting in herdr) no longer freezes the UI.
+
+### Fixed
+- **Quitting gives the terminal back** (#47). `q`, Ctrl+C and termination
+  signals exited without tearing down the renderer, leaving mouse tracking
+  and the alternate screen on — moving the mouse at the shell then printed
+  `51;7;45M…`. tuiboard now restores the terminal before exiting, and the
+  `tuiboard` launcher resets mouse/paste/focus reporting and the cursor after
+  the app ends, whatever way it ended.
+- **`H` on Windows with Codex, OpenCode and Pi** (#41). npm-installed CLIs on
+  Windows are an extensionless sh shim next to `.cmd`/`.ps1`, which herdr
+  can't launch directly ("not a valid Win32 application"); on Windows the
+  resume command is typed into the new pane's shell instead.
+- **Responsive layout follows the renderer's terminal size** (#45), the size
+  the frame is drawn at, instead of `process.stdout.columns`.
+
+### Known issues
+- On Windows, herdr may not detect Pi sessions as agents (#49): they open
+  fine, but without herdr's live state.
+
+## [0.12.0] - 2026-09-17
+
+The Agents zone stops being Claude-Code-only: it now lists **Codex, OpenCode
+and Pi** sessions next to Claude Code, tells them apart at a glance, and
+reopens any of them in whatever terminal and shell you use (#12).
+
+### Added
+- **Codex sessions** (#20). Read-only from Codex's rollout files under
+  `$CODEX_HOME` (default `~/.codex`), including archived and zstd-compressed
+  ones, with names from `session_index.jsonl` / the state DB; resume with
+  `codex resume <id>`. Subagent threads are hidden.
+- **OpenCode sessions** (#17). Read-only from OpenCode's SQLite store
+  (`$XDG_DATA_HOME/opencode/opencode.db`); resume with
+  `opencode --session <id>`.
+- **Pi sessions** (#33). Read-only from Pi's JSONL sessions
+  (`~/.pi/agent/sessions/`, honoring `PI_CODING_AGENT_DIR`,
+  `PI_CODING_AGENT_SESSION_DIR` and `sessionDir`); names from `/name`; resume
+  with `pi --session <id>`.
+- Codex, OpenCode and Pi keep no record of running processes, so their
+  sessions are busy while a turn is open and turn stale once it stops updating
+  for 30 minutes; an open-but-idle TUI of theirs isn't detected.
+- **Harness badge, model and harness filter** (#23). Each session shows a
+  colored `cc` / `cx` / `oc` / `pi` badge and its model (`opus-5`,
+  `gpt-5.5-codex`, …), also in the `o` detail. `f` in the Agents zone cycles
+  all → cc → cx → oc → pi; the active filter shows in the panel title.
+- **Two-line session cards** in the zoomed / fullscreen Agents view: title and
+  age on top, model · branch · directory underneath. The dashboard strip stays
+  one line per session and fits its fields to the real row width, dropping
+  model, then branch, then directory before shortening the title.
+- **Enter opens sessions in any common terminal, not only WezTerm** (#25).
+  tuiboard detects where it runs — tmux, herdr, WezTerm, Windows Terminal (new
+  tab), Ghostty (new window) — and otherwise uses the OS default:
+  `xdg-terminal-exec` on Linux, a new console window on Windows, Terminal.app
+  on macOS. If launching fails, the resume command is copied to the clipboard
+  and the banner says so. New `resume_terminal` option forces one;
+  `resume_command` still wins.
+- **Resumed sessions run in your shell** (#31). `auto` follows the shell you
+  started tuiboard from — on Windows Git Bash (Git's `bin\bash.exe`, never
+  WSL's), Nushell or PowerShell; `$SHELL` elsewhere — and the shell stays open
+  after the agent exits. New `resume_shell` option (`bash | zsh | fish | nu |
+  pwsh | powershell | cmd`) forces one.
+- **Enter diagnostics.** The `o` detail shows the full result of a session's
+  last Enter, and `bun run agents:open <session-id-prefix> [--dry-run]` (in a
+  checkout) prints the detected terminal, shell and exact launch command.
+
+### Changed
+- **Agent CLIs plug in through a common adapter interface** (#16). Claude Code
+  sessions behave as before. The `stale-pid` status is now `stale` (same glyph
+  and color), since not every agent writes PID records.
+- **New `{resume}` token** for `resume_command` and `copy_resume_command`: the
+  selected agent's own resume command. The `copy_resume_command` default is now
+  `cd "{cwd}" && {resume}`; custom templates using `claude --resume
+  {sessionId}` keep working unchanged.
+- **The Agents zone refreshes per agent.** A change under one agent's session
+  store re-scans only that agent, and a session writing non-stop still
+  refreshes at least once a second. Session stores that don't exist yet when
+  tuiboard starts (agent installed later, first session) are picked up within
+  a few seconds instead of needing a restart.
+
+### Fixed
+- **Enter in Windows Terminal** (#29). `wt.exe` (and a Store-installed `pwsh`)
+  are App Execution Aliases that Bun's spawn can't find; Windows launches now
+  go through PowerShell's `Start-Process`, which resolves them. Session
+  directories stored with `/` (OpenCode) are passed as `\`.
+- **Agent directories keep `/` on macOS/Linux** — the shortened path was always
+  joined with `\`.
+
 ## [0.11.0] - 2026-09-16
 
 ### Fixed
@@ -350,6 +474,9 @@ First public release on npm. This entry captures the full feature set at launch.
 
 Built with [OpenTUI](https://opentui.com) + SolidJS on Bun.
 
+[0.13.0]: https://github.com/NazzarenoGiannelli/tuiboard/releases/tag/v0.13.0
+[0.12.0]: https://github.com/NazzarenoGiannelli/tuiboard/releases/tag/v0.12.0
+[0.11.0]: https://github.com/NazzarenoGiannelli/tuiboard/releases/tag/v0.11.0
 [0.10.0]: https://github.com/NazzarenoGiannelli/tuiboard/releases/tag/v0.10.0
 [0.9.2]: https://github.com/NazzarenoGiannelli/tuiboard/releases/tag/v0.9.2
 [0.9.1]: https://github.com/NazzarenoGiannelli/tuiboard/releases/tag/v0.9.1

package/README.md

@@ -3,7 +3,8 @@
 A terminal **kanban** board on plain markdown files, with three optional panels
 you switch on or off: a **Today/Tomorrow planner** across all your boards, a
 **24-hour agenda** with a read-only Google / Microsoft 365 calendar overlay, and
-a **live view of your Claude Code sessions**. Run it as a pure kanban, or any mix
+a **live view of your coding-agent sessions** (Claude Code, Codex, OpenCode, Pi).
+Run it as a pure kanban, or any mix
 of the four. The board is always on; the rest is opt-in (see [Zones](#zones)).
 
 Built with [OpenTUI](https://opentui.com) + SolidJS on Bun. Cross-platform
@@ -11,7 +12,7 @@ Built with [OpenTUI](https://opentui.com) + SolidJS on Bun. Cross-platform
 the Obsidian Tasks-plugin emoji vocabulary, so they open and edit fine in
 any markdown editor.
 
-![tuiboard — kanban board, Today/Tomorrow panel, 24h agenda with calendar overlay, and live Claude Code agents in one terminal dashboard](docs/screenshot.png)
+![tuiboard — kanban board, Today/Tomorrow panel, 24h agenda with calendar overlay, and live coding-agent sessions in one terminal dashboard](docs/screenshot.png)
 
 ## Install
 
@@ -72,10 +73,38 @@ Starting fresh — no Obsidian, no special folders required:
    already contains `.md` files with `- [ ]` tasks — it auto-discovers them.
 4. **Run it:** `tuiboard` (or the short alias `tb`).
 
-**The Agent view needs zero setup.** tuiboard reads your local Claude Code
-sessions from `~/.claude/` automatically, so the live agent strip fills in as
-soon as you've used Claude Code — nothing to connect or configure. (Tools that
-don't write to `~/.claude`, like Codex, won't show up there.)
+**The Agent view needs zero setup.** tuiboard reads your local agent sessions
+automatically, read-only — Claude Code from `~/.claude/`, Codex from
+`~/.codex/` (respects `$CODEX_HOME`), OpenCode from
+`~/.local/share/opencode/opencode.db` (respects `$XDG_DATA_HOME`), Pi from
+`~/.pi/agent/sessions/` (respects `$PI_CODING_AGENT_DIR`,
+`$PI_CODING_AGENT_SESSION_DIR` and `sessionDir`) — so the live agent strip
+fills in as soon as you've used any of them, even if you start the agent after
+tuiboard. Nothing to connect or configure. Codex, OpenCode and Pi keep no
+record of running processes, so their sessions show as busy while a turn is in
+progress (stale if a turn stops updating for 30 minutes), never as
+idle-but-open.
+
+Each session's state uses the same symbols as [herdr](https://herdr.dev):
+`×` waiting for you, `◐` working, `✓` done, `○` idle, `·` closed, plus
+tuiboard's own `△` for a turn that stopped updating (`status_indicators: dots`
+switches to colored dots). **With herdr running**, tuiboard reads its live
+state for every session open in a herdr pane — so "waiting for you", "done"
+and "idle" show up for every agent, and a long Claude turn no longer turns
+stale — and the zoomed cards say where each one lives (`herdr blits · tab 3`).
+herdr reports the exact session when its agent integration is installed
+(`herdr integration install claude|codex|opencode|pi`); otherwise tuiboard
+matches by agent and directory. `H` jumps to a session in herdr — or resumes
+it there, in a new tab of the workspace that holds its project — and Enter on
+a session that's already open in herdr takes you to it instead of starting a
+second copy.
+
+Every session carries a colored two-letter harness badge — `cc` Claude Code,
+`cx` Codex, `oc` OpenCode, `pi` Pi — plus the model it ran on. The dashboard strip keeps
+one line per session (on a narrow row the model gives way first, then the
+branch, then the directory); zoom the Agents zone (`z`) or run
+`tuiboard --view=agents` for two-line cards with the model, branch and full
+directory under each title. `f` in the Agents zone filters by harness.
 
 See [Configure](#configure) for assignees, the done/archive column names, and
 the optional custom "open session in your terminal" command.
@@ -100,11 +129,11 @@ https://github.com/NazzarenoGiannelli/tuiboard). Set it up for me from scratch:
    home path) with a `boards:` list pointing at those files by ABSOLUTE path,
    plus `assignees: [...]`, `done_column: Done`, `archive_column: Archive`.
 4. Ask me which zones I want besides the kanban board: the Today/Tomorrow
-   planner, the 24h agenda, and the live Claude Code agents view. For any I
-   don't want, add a `zones:` block setting it to `off` (e.g. someone who
-   doesn't use Claude Code would set `agents: off`). If I want them all, omit
-   the block. Do NOT configure the agents view beyond on/off — it reads
-   `~/.claude` automatically when enabled.
+   planner, the 24h agenda, and the live agent-sessions view (Claude Code,
+   Codex, OpenCode, Pi). For any I don't want, add a `zones:` block setting it
+   to `off` (e.g. someone who uses none of those agents would set
+   `agents: off`). If I want them all, omit the block. Do NOT configure the
+   agents view beyond on/off — it finds each agent's sessions automatically.
 5. Ask me whether I want to overlay my Google Calendar or Microsoft 365 events
    on the Agenda (skip this if I turned the agenda off). If yes, tell me to run
    `tuiboard calendar-setup google` (or `microsoft`) — it interviews me, opens
@@ -155,31 +184,40 @@ assignees: [Alice, Bob]
 done_column: Done
 archive_column: Archive
 
-# Optional: override Enter in the Agents zone. argv array, {cwd}/{sessionId}
-# substituted, run directly (no shell — element 0 must be a real binary/abs
-# path, NOT a shell builtin or Windows App Execution Alias). Defaults to
-# opening a WezTerm tab with `claude --resume <id>`. For a custom layout:
+# Enter in the Agents zone opens the session in the terminal tuiboard runs in
+# (tmux, herdr, WezTerm, Windows Terminal, Ghostty, else the OS default
+# terminal; clipboard as last resort). Force one if detection guesses wrong:
+# resume_terminal: windows-terminal   # auto (default) | tmux | herdr | wezterm |
+#   ghostty | xdg-terminal-exec | windows-console | macos-terminal
+# The session runs in your shell (auto: the one you started tuiboard from — Git
+# Bash / Nushell / PowerShell on Windows, $SHELL elsewhere). Force one with:
+# resume_shell: bash                  # auto | bash | zsh | fish | nu | pwsh | powershell | cmd
+
+# Optional: replace Enter with your own launcher. argv array, {cwd}/{sessionId}/
+# {resume} substituted, run directly (no shell — element 0 must be a real binary/abs
+# path, NOT a shell builtin or Windows App Execution Alias). Takes precedence
+# over resume_terminal. For a custom layout:
 # resume_command: ["nu", "C:/Users/you/.config/tuiboard/code-resume.nu", "{cwd}", "{sessionId}"]
 
 # Optional: the command `c` copies to the clipboard in the Agents zone — one
 # paste that cd's into the session dir and resumes it, so you can open it
-# yourself in any tab/pane (no WezTerm needed). {cwd}/{sessionId} substituted.
-# Default: 'cd "{cwd}" && claude --resume {sessionId}'. Nushell users:
-# copy_resume_command: 'cd "{cwd}"; claude --resume {sessionId}'
+# yourself in any tab/pane (no WezTerm needed). {cwd}/{sessionId}/{resume}
+# substituted. Default: 'cd "{cwd}" && {resume}'. Nushell users:
+# copy_resume_command: 'cd "{cwd}"; {resume}'
 ```
 
 ## Zones
 
 tuiboard is four zones — **board** (kanban), **planner** (Today/Tomorrow across
 all boards), **agenda** (24h timeline + calendar overlay), and **agents** (live
-Claude Code sessions). Only want some of them? The board is always on; the other
+coding-agent sessions). Only want some of them? The board is always on; the other
 three are yours to configure:
 
 ```yaml
 zones:
   planner: on      # Today/Tomorrow panel          (toggle at runtime with F1)
   agenda: on       # 24h agenda + calendars        (F2)
-  agents: off      # live Claude Code view         (F3)
+  agents: off      # live agent sessions view      (F3)
 ```
 
 Each zone takes one of:
@@ -187,14 +225,14 @@ Each zone takes one of:
 | Value | Behavior |
 |---|---|
 | `on` | Enabled and shown at launch (the default). |
-| `off` | **Disabled entirely** — never rendered, skipped by `Shift-Tab`, its F-key is inert, and its background work never starts (no calendar fetch, no `~/.claude` reads). |
+| `off` | **Disabled entirely** — never rendered, skipped by `Shift-Tab`, its F-key is inert, and its background work never starts (no calendar fetch, no agent session reads). |
 | `hidden` | Enabled but **collapsed at launch** — reveal it any time with its F-key. |
 
 `true`/`false` work as aliases for `on`/`off`. So a pure kanban is just
 `agenda: off` and `agents: off`; kanban + calendar is `agents: off`. The
 difference between `off` and the F-key hide: `off` means the feature never runs
-at all — handy if you don't use Claude Code and don't want tuiboard reading
-`~/.claude`.
+at all — handy if you use none of the supported agents and don't want
+tuiboard reading their session stores.
 
 ## Calendars (Agenda overlay)
 
@@ -376,7 +414,7 @@ Launch `tuiboard` with no flag for the default dashboard (every enabled zone).
 |---|---|---|
 | (none) | **Dashboard** — every enabled zone | Default; your configured layout |
 | `--view=planner` | Today/Tomorrow alone, full width | A narrow vertical strip beside other work |
-| `--view=board` | Kanban + planner panel only | Focus mode, or a single WezTerm pane |
+| `--view=board` | Kanban + planner panel only | Focus mode, or a single terminal pane |
 | `--view=timeline` | Timeline fullscreen | Wall-mounted "what's now" |
 | `--view=agents` | Agent view fullscreen | Cross-machine session monitor |
 
@@ -404,10 +442,9 @@ session (until the next terminal resize).
 | `v` | Toggle Today/Tomorrow planner panel focus |
 | `Shift-Tab` | Cycle active zone (planner → board → timeline → agents) |
 | `+` | New board — create one, or adopt markdown files you already have (also the `+` chip in the top bar) |
-| `z` | Focus one pane (single-pane mode) — automatic below 100 columns |
 | `h` / `l` | In single-pane, walk the ring: planner → each column → agenda → agents, wrapping |
 | `F1` / `F2` / `F3` | Toggle visibility of Planner / Timeline / Agents zones |
-| `z` | Zoom active zone to full screen |
+| `z` | Zoom active zone to full screen (single-pane below 100 columns is automatic, not triggered by `z`) |
 | `r` | Refresh everything — reload boards from disk, rescan agents, force-refetch the agenda calendar (bypasses the 30-min cache) |
 
 ### Agenda (timeline zone)
@@ -425,9 +462,11 @@ session (until the next terminal resize).
 | Key | Action |
 |---|---|
 | `j` / `k` | Move the cursor down / up the session list |
-| `Enter` | Open (resume) the selected session in a new WezTerm tab |
-| `c` | Copy a one-paste `cd … && claude --resume <id>` command for the selected session — drop it into any tab/pane to land in the right dir and resume (no WezTerm needed; format is `copy_resume_command`) |
-| `o` | Session detail (cwd, branch, last prompts, resume command) |
+| `Enter` | Go to the session if it's open in herdr; otherwise open (resume) it in a new tab/window of your terminal — tmux, herdr, WezTerm, Windows Terminal, Ghostty, or the OS default; falls back to copying the command (`resume_terminal` to force one) |
+| `c` | Copy a one-paste `cd … && <resume>` command (e.g. `claude --resume <id>`) for the selected session — drop it into any tab/pane to land in the right dir and resume (no WezTerm needed; format is `copy_resume_command`) |
+| `o` | Session detail (harness, model, cwd, branch, last prompts, resume command, result of the last `Enter`) |
+| `H` | herdr: go to the session's pane, or resume it in a new tab of its project's workspace (herdr must be running) |
+| `f` | Filter by harness: all → `cc` Claude Code → `cx` Codex → `oc` OpenCode → `pi` Pi (shown in the panel title; outside the Agents zone `f` is the board filter) |
 
 ### Task actions (work in board, planner, AND timeline zones)
 
@@ -530,10 +569,57 @@ An ambiguous match is refused rather than guessed at.
 Exit 3 is the mtime watermark: a write is refused rather than allowed to
 clobber an edit made in the TUI or another editor in the meantime.
 
+## Omarchy bar widget
+
+On [Omarchy](https://omarchy.org), `omarchy-plugin/` ships a bar widget built
+on `tuiboard summary` and `tuiboard task`: an overdue/today badge in the bar,
+and a panel with the Today/Tomorrow planner where a task can be marked
+done/undone or deferred to tomorrow without leaving the bar. Right-click the
+badge to force a refresh, middle-click to open tuiboard itself.
+
+**Requires** `tuiboard` on `PATH` (see [Install](#install) above) and Omarchy
+with its shell plugin support.
+
+**Install** (from a checkout of this repo):
+
+```bash
+git clone https://github.com/NazzarenoGiannelli/tuiboard.git
+cd tuiboard
+./omarchy-plugin/install.sh
+```
+
+This symlinks `omarchy-plugin/` into `~/.config/omarchy/plugins/nazz.tuiboard`
+and enables it in the bar's right section. `omarchy plugin add <git-url>`
+isn't used here — it clones a git repo and expects `manifest.json` at its
+root, which doesn't fit a widget living inside this monorepo, and there's no
+separate Omarchy plugin marketplace to publish to at the time of writing. The
+symlink means `omarchy plugin update` doesn't apply; update by pulling this
+repo instead (`git pull`, then `omarchy-shell shell rescanPlugins` if the bar
+doesn't pick it up on its own).
+
+Refresh interval, the `tuiboard summary`/`tuiboard task` commands, the open
+command, and the completion sound are all configurable from Omarchy's own
+plugin settings (`manifest.json`'s schema) — no config file to hand-edit.
+
+Uninstall: `omarchy plugin remove nazz.tuiboard`.
+
 ## Status
 
 See [CHANGELOG.md](CHANGELOG.md) for the full release history.
 
+- **v0.13** — tuiboard + herdr: live agent state from herdr (waiting for you,
+  working, done, idle) with herdr's status symbols, `H` to jump to a session
+  in herdr or resume it in its project's workspace, sessions sorted by most
+  recent activity, and the terminal properly restored on quit.
+- **v0.12** — the Agents zone goes multi-agent: Codex, OpenCode and Pi sessions
+  next to Claude Code, with a colored harness badge, the model, a harness
+  filter (`f`) and two-line cards when zoomed. Enter reopens a session in the
+  terminal and shell you're using — Windows Terminal, Ghostty, tmux, herdr,
+  WezTerm, Git Bash, Nushell… — instead of WezTerm only.
+- **v0.11** — zoomed columns no longer clip task titles short of the available
+  width, a board's custom name survives external edits instead of reverting to
+  the filename, and the keyboard reference (`?`) got a scroll + visual restyle
+  grouped by section.
 - **v0.10** — a task's note, read inside tuiboard: when a task's title is a
   link, `o` shows that note's text instead of pointing at Obsidian. Works with
   plain markdown links too, so the convention needs no vault.
@@ -553,7 +639,7 @@ See [CHANGELOG.md](CHANGELOG.md) for the full release history.
 - **v0.5** — daily-driver ready. Kanban + planner + timeline + agents
   all functional, multi-select, undo, atomic file roundtrip, mouse click,
   responsive layout. Tested on Windows with WezTerm; Linux/macOS should
-  work via the same OpenTUI binaries (untested).
+  work via the same OpenTUI binaries (untested at the time).
 
 ## Contributing
 

package/bin/tuiboard.ts

@@ -85,8 +85,17 @@ const child = spawn(
     env: { ...process.env, TUIBOARD_SPLASH_DONE: "1", TUIBOARD_READY_FLAG: readyFlag },
   },
 );
+// Safety net: whatever way the app ended (crash, kill), give the shell a sane
+// terminal back — mouse reporting off (else moving the mouse prints
+// `51;7;45M…`), focus/paste reporting off, cursor visible. Harmless when the
+// app already restored everything.
+const RESET_TERMINAL =
+  "\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1015l" + // mouse
+  "\x1b[?1004l\x1b[?2004l" + // focus events, bracketed paste
+  "\x1b[?25h"; // cursor
 child.on("exit", (code, signal) => {
   stopSplash();
+  try { process.stdout.write(RESET_TERMINAL); } catch { /* ignore */ }
   process.exit(code ?? (signal ? 1 : 0));
 });
 child.on("error", (err) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tuiboard",
-  "version": "0.11.0",
-  "description": "Terminal kanban for markdown task boards, with optional Today/Tomorrow planner, 24h agenda + calendar overlay, and a live Claude Code agent view. Use only the panels you want.",
+  "version": "0.13.0",
+  "description": "Terminal kanban for markdown task boards, with optional Today/Tomorrow planner, 24h agenda + calendar overlay, and a live view of your coding-agent sessions (Claude Code, Codex, OpenCode, Pi). Use only the panels you want.",
   "type": "module",
   "license": "MIT",
   "author": "Nazzareno Giannelli <nazzareno.giannelli@gmail.com>",
@@ -50,6 +50,7 @@
     "typecheck": "tsc --noEmit",
     "test": "bun test",
     "agents:check": "bun run src/scripts/agents-check.ts",
+    "agents:open": "bun run src/scripts/agents-open.ts",
     "summary": "bun run src/cli/summary.ts",
     "prepublishOnly": "bun run typecheck && bun test"
   },

package/src/app-exit.ts

@@ -0,0 +1,37 @@
+/**
+ * The one way out of the TUI. Destroying the OpenTUI renderer is what gives
+ * the terminal back — mouse tracking off, main screen, cooked input, cursor —
+ * and a bare `process.exit` skips it (OpenTUI only cleans up on `beforeExit`
+ * and its own signal/Ctrl+C handling), which left shells printing mouse
+ * reports like `51;7;45M` after quitting.
+ */
+
+import type { CliRenderer } from "@opentui/core";
+
+let renderer: CliRenderer | undefined;
+let quitting = false;
+
+export function registerRenderer(r: CliRenderer): void {
+  renderer = r;
+}
+
+/** Restore the terminal, run `cleanup`, exit. Safe to call more than once. */
+export async function quitApp(cleanup: () => Promise<void>, code = 0): Promise<never> {
+  if (!quitting) {
+    quitting = true;
+    try {
+      renderer?.destroy();
+      // A destroy requested mid-frame completes when that frame ends.
+      await new Promise((r) => setTimeout(r, 50));
+    } catch {
+      // Never let a teardown error keep the process alive.
+    }
+    try {
+      await cleanup();
+    } catch {
+      // Same.
+    }
+    process.exit(code);
+  }
+  return new Promise<never>(() => {});
+}

package/src/app.tsx

@@ -21,8 +21,11 @@ import { appendFileSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
-import { createMemo } from "solid-js";
-import { render, useKeyboard } from "@opentui/solid";
+import { createEffect, createMemo } from "solid-js";
+import { createCliRenderer } from "@opentui/core";
+import { render, useKeyboard, useTerminalDimensions } from "@opentui/solid";
+
+import { quitApp, registerRenderer } from "~/app-exit";
 
 import { parseArgs, type ViewKind } from "~/cli/args";
 import { loadConfig } from "~/config/loader";
@@ -84,12 +87,8 @@ if (needsOnboarding) {
   store.openBoardNew(true);
 }
 
-process.on("SIGINT", () => {
-  store.dispose().finally(() => process.exit(0));
-});
-process.on("SIGTERM", () => {
-  store.dispose().finally(() => process.exit(0));
-});
+process.on("SIGINT", () => void quitApp(() => store.dispose()));
+process.on("SIGTERM", () => void quitApp(() => store.dispose()));
 
 // ─── Responsive layout ──────────────────────────────────────────────────────
 // Auto-hide optional zones when the terminal isn't wide enough to host them
@@ -102,8 +101,7 @@ process.on("SIGTERM", () => {
 // This only reports what FITS. The store combines it with each zone's enabled
 // flag and the user's desired visibility, so F1/F2/F3 toggles persist across
 // resizes and a disabled/hidden zone is never force-shown.
-function applyResponsiveLayout(): void {
-  const width = process.stdout.columns ?? 200;
+function applyResponsiveLayout(width: number): void {
   // Report which zones FIT at this width. The store ANDs this with each zone's
   // enabled flag and the user's desired visibility, so a disabled or
   // intentionally-hidden zone is never force-shown just because there's room.
@@ -122,8 +120,11 @@ function applyResponsiveLayout(): void {
     { narrow: width < 100 },
   );
 }
-applyResponsiveLayout();
-process.stdout.on("resize", applyResponsiveLayout);
+// Initial guess before the renderer exists; from then on the layout follows
+// OpenTUI's own dimensions (see App). `process.stdout.columns` can lag behind
+// the real size — e.g. a Windows Terminal tab that starts at a provisional
+// size — which left zones overlapping until a manual resize.
+applyResponsiveLayout(process.stdout.columns ?? 200);
 
 // Land on the Today/Tomorrow panel by default — for a daily-planning tool the
 // first question is "what's on my plate today", and that panel answers it.
@@ -170,6 +171,13 @@ function App() {
 
   useKeyboard((key) => handleKey(store, key, plannerItems().length));
 
+  // Same width the frame is drawn at, updated on the renderer's resize events.
+  const dims = useTerminalDimensions();
+  createEffect(() => {
+    const { width } = dims();
+    if (width > 0) applyResponsiveLayout(width);
+  });
+
   return (
     <box
       style={{
@@ -226,4 +234,6 @@ if (process.env.TUIBOARD_READY_FLAG) {
   }
 }
 
-await render(() => <App />, { useMouse: true });
+const renderer = await createCliRenderer({ useMouse: true });
+registerRenderer(renderer);
+await render(() => <App />, renderer);