tuiboard 0.11.0 → 0.12.0

package/.tuiboard/config.example.yaml

@@ -43,13 +43,32 @@ 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
+#
+# 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 +84,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,75 @@ 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.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 +419,8 @@ First public release on npm. This entry captures the full feature set at launch.
 
 Built with [OpenTUI](https://opentui.com) + SolidJS on Bun.
 
+[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,24 @@ 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.
+
+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 +115,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 +170,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 +211,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 +400,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 +428,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 +448,10 @@ 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` | Open (resume) the selected session 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`) |
+| `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)
 
@@ -534,6 +558,15 @@ clobber an edit made in the TUI or another editor in the meantime.
 
 See [CHANGELOG.md](CHANGELOG.md) for the full release history.
 
+- **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 +586,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/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.12.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/config/loader.ts

@@ -19,6 +19,7 @@ import { dirname, isAbsolute, join, resolve } from "node:path";
 import * as YAML from "js-yaml";
 
 import { isBoardFile } from "~/boards/scan";
+import { LAUNCHERS, SHELLS, type Launcher, type Shell } from "~/input/open-session";
 
 export interface BoardConfig {
   /** Path to the .md file, absolute or relative to the config directory. */
@@ -38,20 +39,34 @@ export interface Config {
   archiveColumn: string;
   /**
    * Optional override for "open the selected agent session" (Enter in the
-   * agents zone). An argv array; the tokens `{cwd}` and `{sessionId}` are
-   * substituted, then it's spawned directly (no shell). Point it at your own
+   * agents zone). An argv array; the tokens `{cwd}`, `{sessionId}` and
+   * `{resume}` (the agent's own resume command, e.g. `claude --resume <id>`)
+   * are substituted, then it's spawned directly (no shell). Point it at your own
    * script to launch a custom terminal layout — e.g.
    *   ["pwsh", "-NoProfile", "-File", "C:/.../code-resume.ps1", "{cwd}", "{sessionId}"]
-   * When unset, tuiboard falls back to opening a tab + `claude --resume <id>`.
+   * When unset, tuiboard falls back to opening a tab + the agent's resume command.
    */
   resumeCommand?: string[];
+  /**
+   * Terminal Enter opens sessions in (config `resume_terminal`). `auto`
+   * detects it from the environment; set one explicitly when detection
+   * guesses wrong. Ignored when `resumeCommand` is set.
+   */
+  resumeTerminal: "auto" | Launcher;
+  /**
+   * Shell the resumed session runs in (config `resume_shell`). `auto` = the
+   * shell tuiboard was started from (Git Bash / Nushell / PowerShell on
+   * Windows, `$SHELL` elsewhere). Ignored when `resumeCommand` is set.
+   */
+  resumeShell: "auto" | Shell;
   /**
    * Template for the shell command copied to the clipboard by `c` in the agents
    * zone — one paste that `cd`s into the session's directory and resumes it.
-   * The tokens `{cwd}` and `{sessionId}` are substituted. Default:
-   *   cd "{cwd}" && claude --resume {sessionId}
+   * The tokens `{cwd}`, `{sessionId}` and `{resume}` (the agent's own resume
+   * command, e.g. `claude --resume <id>`) are substituted. Default:
+   *   cd "{cwd}" && {resume}
    * `&&` works in bash/zsh/pwsh/cmd; Nushell users may prefer
-   *   cd "{cwd}"; claude --resume {sessionId}
+   *   cd "{cwd}"; {resume}
    */
   copyResumeCommand: string;
   /**
@@ -118,12 +133,14 @@ export interface CalendarsConfig {
  * paste. `&&` chains in bash/zsh/pwsh/cmd (Nushell users override with `;`).
  */
 export const DEFAULT_COPY_RESUME_COMMAND =
-  'cd "{cwd}" && claude --resume {sessionId}';
+  'cd "{cwd}" && {resume}';
 
 export const DEFAULT_CONFIG: Omit<Config, "root" | "loaded" | "boards"> = {
   assignees: [],
   doneColumn: "Done",
   archiveColumn: "Archive",
+  resumeTerminal: "auto",
+  resumeShell: "auto",
   copyResumeCommand: DEFAULT_COPY_RESUME_COMMAND,
   zones: { planner: "on", agenda: "on", agents: "on" },
 };
@@ -197,6 +214,8 @@ interface RawConfig {
   done_column: string;
   archive_column: string;
   resume_command: string[];
+  resume_terminal: string;
+  resume_shell: string;
   copy_resume_command: string;
   calendars: {
     google?: {
@@ -342,6 +361,12 @@ function normalize(raw: Partial<RawConfig>, root: string, loaded: boolean): Conf
       Array.isArray(raw.resume_command) && raw.resume_command.length > 0
         ? raw.resume_command.map(String)
         : undefined,
+    resumeTerminal: (LAUNCHERS as readonly string[]).includes(raw.resume_terminal ?? "")
+      ? (raw.resume_terminal as Launcher)
+      : "auto",
+    resumeShell: (SHELLS as readonly string[]).includes(raw.resume_shell ?? "")
+      ? (raw.resume_shell as Shell)
+      : "auto",
     copyResumeCommand:
       typeof raw.copy_resume_command === "string" &&
       raw.copy_resume_command.trim().length > 0

package/src/input/handleKey.ts

@@ -14,6 +14,15 @@
  */
 
 import { isHiddenColumn } from "~/config/loader";
+import {
+  LAUNCHER_NAME,
+  describePlan,
+  detectLauncher,
+  planLaunch,
+  runLaunchPlan,
+  systemLaunchEnv,
+} from "~/input/open-session";
+import { HARNESS, type AgentSession } from "~/store/agents";
 import { googleTokenCanWrite } from "~/store/calendar";
 import { isTask } from "~/parser/markdown";
 import {
@@ -227,6 +236,13 @@ export function handleKey(
   // Cycle the board filter — affects which open tasks show up in board
   // columns. Mirrors Python kanban `action_cycle_filter`. Cycle order:
   // all → today → overdue → tomorrow → followup → all.
+  // In the Agents zone `f` filters sessions by harness instead.
+  if (key.name === "f" && ui.activeZone === "agents") {
+    const next = store.cycleAgentsFilter();
+    const label = next === "all" ? "all harnesses" : `${HARNESS[next].code} · ${HARNESS[next].name}`;
+    store.flashBanner("info", `Agents: ${label}`);
+    return;
+  }
   if (key.name === "f") {
     const cycle = ["all", "today", "overdue", "tomorrow", "followup"] as const;
     const idx = cycle.indexOf(ui.filter);
@@ -477,24 +493,25 @@ function handleTimelineZone(
 
 function handleAgentsZone(store: TuiStore, key: KeyEvent): void {
   const ui = store.state.ui;
-  const sessions = store.agents.sessions();
+  const sessions = store.agentSessions();
   if (key.name === "j" || key.name === "down") {
     store.setCursor(0, Math.min(sessions.length - 1, ui.row + 1));
   } else if (key.name === "k" || key.name === "up") {
     store.setCursor(0, Math.max(0, ui.row - 1));
   } else if (key.name === "enter" || key.name === "return") {
-    // Open (resume) the selected session in a new WezTerm tab.
+    // Open (resume) the selected session in a new terminal tab/window.
     const target = sessions[ui.row];
-    if (target) void openSessionInWezterm(store, target.cwd, target.sessionId);
+    if (target) void openSession(store, target);
   } else if (key.name === "c") {
     // Copy a one-paste "cd + resume" command for the selected session, so you
     // can drop it into any tab/pane anywhere and land in the right directory
-    // resuming the right session (no WezTerm dependency, unlike Enter).
+    // resuming the right session (works in any terminal, unlike Enter).
     const target = sessions[ui.row];
     if (target) {
       const cmd = store.config.copyResumeCommand
         .replaceAll("{cwd}", target.cwd)
-        .replaceAll("{sessionId}", target.sessionId);
+        .replaceAll("{sessionId}", target.sessionId)
+        .replaceAll("{resume}", target.resumeCommand);
       copyToClipboard(cmd).then(
         () => store.flashBanner("info", `📋 Copied resume command (${target.sessionId.slice(0, 8)})`),
         (err) => store.flashBanner("error", `Copy failed: ${err}`),
@@ -867,33 +884,26 @@ function fmtHm(m: number): string {
 }
 
 /**
- * Open (resume) a Claude Code session in a new WezTerm tab.
- *
- * Two steps:
- *   1. `wezterm cli spawn --cwd <cwd>` opens a new tab running your DEFAULT
- *      shell in the session's directory (prints the new pane id).
- *   2. `wezterm cli send-text` types `claude --resume <id>` + Enter into it.
- *
- * Running it through the interactive shell (rather than `spawn -- claude …`
- * directly) means `claude` gets your full shell environment — PATH, env vars,
- * any wrapper — which is why the direct form exited 1. And if `claude` still
- * errors, you're left at a live prompt that shows it instead of a vanishing
- * tab. Failures (not inside WezTerm, `wezterm` off PATH) surface as a banner.
+ * Open (resume) an agent session in a new tab/window of the terminal tuiboard
+ * runs in — tmux, herdr, WezTerm, Windows Terminal, Ghostty, or the OS default
+ * — inside the user's shell (see open-session.ts). Config `resume_terminal` /
+ * `resume_shell` force them. When nothing can open it, the resume command lands
+ * on the clipboard instead. The outcome is kept for the session's detail modal.
  */
-async function openSessionInWezterm(
-  store: TuiStore,
-  cwd: string,
-  sessionId: string,
-): Promise<void> {
-  const { spawn, spawnSync } = await import("node:child_process");
+async function openSession(store: TuiStore, session: AgentSession): Promise<void> {
+  const { spawn } = await import("node:child_process");
+  const { cwd, sessionId } = session;
 
   // Custom override (config `resume_command`): an argv array with {cwd} /
-  // {sessionId} placeholders, spawned directly (no shell). Lets you launch a
-  // personal terminal layout without baking it into the distributed tool.
+  // {sessionId} / {resume} placeholders, spawned directly (no shell). Lets you
+  // launch a personal terminal layout without baking it into the distributed tool.
   const custom = store.config.resumeCommand;
   if (custom && custom.length > 0) {
     const argv = custom.map((arg) =>
-      arg.replaceAll("{cwd}", cwd).replaceAll("{sessionId}", sessionId),
+      arg
+        .replaceAll("{cwd}", cwd)
+        .replaceAll("{sessionId}", sessionId)
+        .replaceAll("{resume}", session.resumeCommand),
     );
     const [cmd, ...rest] = argv;
     try {
@@ -909,39 +919,43 @@ async function openSessionInWezterm(
         store.flashBanner("error", `resume_command failed: ${e.message}`),
       );
       child.unref();
-      store.flashBanner("info", `↗ Opening session (${sessionId.slice(0, 8)})`);
+      store.flashBanner("info", `↗ Opening session via resume_command (${sessionId.slice(0, 8)})`);
     } catch (e) {
       store.flashBanner("error", `resume_command failed: ${String(e)}`);
     }
     return;
   }
 
-  try {
-    const spawned = spawnSync("wezterm", ["cli", "spawn", "--cwd", cwd], {
-      encoding: "utf8",
-      windowsHide: true,
-    });
-    if (spawned.error) {
-      store.flashBanner("error", `WezTerm launch failed: ${spawned.error.message}`);
-      return;
-    }
-    if (spawned.status !== 0) {
-      store.flashBanner(
-        "error",
-        `WezTerm spawn failed: ${(spawned.stderr || "").trim() || `exit ${spawned.status}`}`,
-      );
-      return;
-    }
-    const paneId = spawned.stdout.trim();
-    // Type the resume command into the fresh pane (\r submits, like Enter).
-    spawnSync(
-      "wezterm",
-      ["cli", "send-text", "--pane-id", paneId, "--no-paste"],
-      { input: `claude --resume ${sessionId}\r`, encoding: "utf8", windowsHide: true },
+  const launchEnv = systemLaunchEnv();
+  const forced = store.config.resumeTerminal;
+  const launcher = forced === "auto" ? detectLauncher(launchEnv) : forced;
+  const fail = async (why: string) => {
+    const copied = await copyToClipboard(session.resumeCommand).then(
+      () => true,
+      () => false,
     );
-    store.flashBanner("info", `↗ Opened session in WezTerm (${sessionId.slice(0, 8)})`);
+    const text = copied ? `${why} — resume command copied, paste it in ${cwd}` : why;
+    store.setLastLaunch(sessionId, false, text);
+    store.flashBanner(copied ? "warn" : "error", text);
+  };
+
+  if (!launcher) {
+    await fail("No supported terminal detected (set resume_terminal)");
+    return;
+  }
+  const plan = planLaunch(
+    launcher,
+    { cwd, resume: session.resumeCommand, shell: store.config.resumeShell },
+    launchEnv,
+  );
+  try {
+    await runLaunchPlan(plan);
+    const text = `↗ Opened session in ${LAUNCHER_NAME[launcher]} (${sessionId.slice(0, 8)})`;
+    store.setLastLaunch(sessionId, true, `${text}\n${describePlan(plan)}`);
+    store.flashBanner("info", text);
   } catch (e) {
-    store.flashBanner("error", `WezTerm launch failed: ${String(e)}`);
+    const msg = e instanceof Error ? e.message : String(e);
+    await fail(`${LAUNCHER_NAME[launcher]} launch failed: ${msg}`);
   }
 }