tuiboard 0.6.2 → 0.7.0

package/.tuiboard/config.example.yaml

@@ -31,6 +31,20 @@ done_column: Done
 # doesn't exist in a board, tuiboard creates it on the fly.
 archive_column: Archive
 
+# Optional: pick which zones you want. The board is always on; the other three
+# are yours to turn off. Each takes one of:
+#   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 runs (no calendar fetch, no
+#           ~/.claude reads). Use this for a pure kanban, or kanban + one panel.
+#   hidden  enabled but collapsed at launch — reveal it any time with its F-key
+# Want just a kanban? Set agenda and agents to off. (true/false also work.)
+#
+# zones:
+#   planner: on      # Today/Tomorrow cross-board panel        (F1)
+#   agenda: on       # 24h agenda + calendar overlay           (F2)
+#   agents: on       # live Claude Code session 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
 # substituted, then it's run directly (no shell). Point it at your own script

package/README.md

@@ -1,6 +1,6 @@
 # tuiboard
 
-A terminal dashboard that unifies **kanban**, a **Today/Tomorrow virtual
+A terminal dashboard that unifies **kanban**, a **Today/Tomorrow planner
 panel**, a **24-hour agenda** (with a read-only Google / Microsoft 365
 calendar overlay), and a **live agent view** for Claude Code sessions — all
 on top of plain markdown task files.
@@ -98,12 +98,17 @@ https://github.com/NazzarenoGiannelli/tuiboard). Set it up for me from scratch:
 3. Create a global config at `~/.config/tuiboard/config.yaml` (resolve the real
    home path) with a `boards:` list pointing at those files by ABSOLUTE path,
    plus `assignees: [...]`, `done_column: Done`, `archive_column: Archive`.
-4. Do NOT configure the Agent view — tuiboard reads `~/.claude` automatically.
+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.
 5. Ask me whether I want to overlay my Google Calendar or Microsoft 365 events
-   on the Agenda. If yes, tell me to run `tuiboard calendar-setup google` (or
-   `microsoft`) — it interviews me, opens the browser, and prints the exact
-   `calendars:` YAML block to add. Don't try to do the OAuth yourself. If no,
-   skip it (it's optional and can be added later).
+   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
+   the browser, and prints the exact `calendars:` YAML block to add. Don't try
+   to do the OAuth yourself. If no, skip it (it's optional and can be added later).
 6. Show me the final config, then tell me to run `tuiboard`, and how to add a
    board later (create a new `.md` and append it to the `boards:` list).
 
@@ -143,6 +148,34 @@ archive_column: Archive
 # resume_command: ["nu", "C:/Users/you/.config/tuiboard/code-resume.nu", "{cwd}", "{sessionId}"]
 ```
 
+## 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
+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)
+```
+
+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). |
+| `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`.
+
 ## Calendars (Agenda overlay)
 
 The **Agenda** zone (the 24h timeline) can overlay read-only events from Google
@@ -241,7 +274,7 @@ Launch `tuiboard` with no flag for the default 4-zone dashboard.
 | Flag | View | Use case |
 |---|---|---|
 | (none) | **Dashboard** — all 4 zones | Default; everything in one terminal |
-| `--view=board` | Kanban + virtual panel only | Focus mode, or a single WezTerm pane |
+| `--view=board` | Kanban + planner panel only | Focus mode, or a single WezTerm pane |
 | `--view=timeline` | Timeline fullscreen | Wall-mounted "what's now" |
 | `--view=agents` | Agent view fullscreen | Cross-machine session monitor |
 
@@ -249,9 +282,9 @@ The dashboard auto-collapses optional zones on narrow terminals:
 
 | Terminal width | Default zones visible |
 |---|---|
-| ≥ 150 cols | virtual + board + timeline + agents |
-| 120–149 | virtual + board + agents |
-| 100–119 | virtual + board |
+| ≥ 150 cols | planner + board + timeline + agents |
+| 120–149 | planner + board + agents |
+| 100–119 | planner + board |
 | < 100 | board only |
 
 `F1` / `F2` / `F3` toggles override the auto-collapse for the current
@@ -266,9 +299,9 @@ session (until the next terminal resize).
 | `h j k l` / arrows | Move cursor inside the active zone |
 | `Tab` | Cycle to next board |
 | `1`..`9` | Jump to board N |
-| `v` | Toggle Today/Tomorrow virtual panel focus |
-| `Shift-Tab` | Cycle active zone (virtual → board → timeline → agents) |
-| `F1` / `F2` / `F3` | Toggle visibility of Virtual / Timeline / Agents zones |
+| `v` | Toggle Today/Tomorrow planner panel focus |
+| `Shift-Tab` | Cycle active zone (planner → board → timeline → agents) |
+| `F1` / `F2` / `F3` | Toggle visibility of Planner / Timeline / Agents zones |
 | `z` | Zoom active zone to full screen |
 | `r` | Refresh everything — reload boards from disk, rescan agents, force-refetch the agenda calendar (bypasses the 30-min cache) |
 
@@ -282,7 +315,7 @@ session (until the next terminal resize).
 | `j` / `k` | While armed: nudge the block ±15 min |
 | `+` / `-` | While armed: resize the block's end ±15 min |
 
-### Task actions (work in board, virtual, AND timeline zones)
+### Task actions (work in board, planner, AND timeline zones)
 
 | Key | Action |
 |---|---|
@@ -320,10 +353,13 @@ session (until the next terminal resize).
 
 ## Status
 
+- **v0.7** — configurable zones: turn the planner, agenda, or agents view off
+  (or start it collapsed) via the `zones:` config, so tuiboard can be a pure
+  kanban, kanban + calendar, or any mix.
 - **v0.6** — adds the Agenda calendar overlay (Google + Microsoft 365,
   read-only, BYO credentials), day-navigation (`[` / `]` / `\`) to page tasks
   and events across days, and a manual full-refresh key (`r`).
-- **v0.5** — daily-driver ready. Kanban + virtual + timeline + agents
+- **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).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tuiboard",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "description": "Terminal dashboard for markdown task boards. Kanban + Today/Tomorrow + 24h timeline + Claude Code agent view, all in one TUI.",
   "type": "module",
   "license": "MIT",

package/src/app.tsx

@@ -4,7 +4,7 @@
  * Loads config, builds the reactive store, parses argv, and dispatches
  * to one of four root views:
  *   - undefined → Dashboard (all 4 zones)
- *   - "board"   → BoardOnly  (kanban + virtual fullscreen)
+ *   - "board"   → BoardOnly  (kanban + planner fullscreen)
  *   - "timeline"→ TimelineOnly
  *   - "agents"  → AgentsOnly
  *
@@ -22,7 +22,7 @@ import {
   createTuiStore,
   type TuiStore,
 } from "~/store/index";
-import { buildVirtualItems } from "~/store/virtual-panel";
+import { buildPlannerItems } from "~/store/planner-panel";
 import { T } from "~/ui/glyphs";
 import { TopBar, BottomBar } from "~/ui/Chrome";
 import { ModalLayer } from "~/ui/Modal";
@@ -62,16 +62,21 @@ process.on("SIGTERM", () => {
 //   ≥ 150 col → all four zones
 //   120–149   → hide timeline
 //   100–119   → hide agents too
-//   < 100     → hide virtual too (board is non-hideable)
+//   < 100     → hide planner too (board is non-hideable)
 //
-// User F1/F2/F3 toggles still work — they last until the next resize, at
-// which point auto re-evaluates. Acceptable trade-off: resize events are
-// rare, predictable layout > sticky overrides.
+// 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;
-  store.setZoneVisible("timeline", width >= 150);
-  store.setZoneVisible("agents", width >= 120);
-  store.setZoneVisible("virtual", width >= 100);
+  // 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.
+  store.applyResponsiveFits({
+    planner: width >= 100,
+    timeline: width >= 150,
+    agents: width >= 120,
+  });
 }
 applyResponsiveLayout();
 process.stdout.on("resize", applyResponsiveLayout);
@@ -79,8 +84,8 @@ process.stdout.on("resize", applyResponsiveLayout);
 // 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. On
 // a narrow terminal where the panel auto-hides, fall back to the board.
-if (store.state.ui.visibleZones.virtual) {
-  store.setActiveZone("virtual");
+if (store.state.ui.visibleZones.planner) {
+  store.setActiveZone("planner");
 }
 
 const { view } = parseArgs(process.argv.slice(2));
@@ -97,11 +102,11 @@ function rootViewFor(v: ViewKind | undefined, s: TuiStore) {
 }
 
 function App() {
-  const virtualItems = createMemo(() =>
-    buildVirtualItems(store.state.boards.map((b) => b.board)),
+  const plannerItems = createMemo(() =>
+    buildPlannerItems(store.state.boards.map((b) => b.board)),
   );
 
-  useKeyboard((key) => handleKey(store, key, virtualItems().length));
+  useKeyboard((key) => handleKey(store, key, plannerItems().length));
 
   return (
     <box

package/src/config/loader.ts

@@ -49,6 +49,30 @@ export interface Config {
    * Tokens are produced by `tuiboard calendar-setup`.
    */
   calendars?: CalendarsConfig;
+  /**
+   * Which optional zones are enabled and how they start. The board zone is
+   * always on (load-bearing) and not configurable here.
+   */
+  zones: ZonesConfig;
+}
+
+/**
+ * Per-zone startup mode:
+ *   - "on"     → enabled and visible at launch (default)
+ *   - "off"    → disabled entirely: never rendered, skipped by Shift-Tab, its
+ *                F-key is inert, and its background work (calendar fetch /
+ *                `~/.claude` watcher) never starts
+ *   - "hidden" → enabled but collapsed at launch; reveal it with its F-key
+ */
+export type ZoneMode = "on" | "off" | "hidden";
+
+export interface ZonesConfig {
+  /** Today/Tomorrow cross-board panel. */
+  planner: ZoneMode;
+  /** 24h agenda + calendar overlay (internally the "timeline" zone). */
+  agenda: ZoneMode;
+  /** Live Claude Code session view. */
+  agents: ZoneMode;
 }
 
 export interface GoogleCalendarConfig {
@@ -79,6 +103,7 @@ export const DEFAULT_CONFIG: Omit<Config, "root" | "loaded" | "boards"> = {
   assignees: [],
   doneColumn: "Done",
   archiveColumn: "Archive",
+  zones: { planner: "on", agenda: "on", agents: "on" },
 };
 
 /**
@@ -135,6 +160,13 @@ interface RawConfig {
       color?: string;
     };
   };
+  // Values may be boolean (js-yaml parses on/off/yes/no → boolean) or the
+  // string "hidden"/"collapsed". Anything else falls back to "on".
+  zones: {
+    planner?: boolean | string;
+    agenda?: boolean | string;
+    agents?: boolean | string;
+  };
 }
 
 /** Expand `~` to the home dir; resolve relative paths against the config dir. */
@@ -173,6 +205,24 @@ function normalizeCalendars(
   return out.google || out.microsoft ? out : undefined;
 }
 
+/** Normalize one zone's raw value to a ZoneMode. Default (undefined) → "on". */
+function normalizeZoneMode(v: boolean | string | undefined): ZoneMode {
+  if (v === undefined || v === true) return "on";
+  if (v === false) return "off";
+  const s = String(v).toLowerCase();
+  if (s === "off" || s === "false" || s === "no" || s === "none") return "off";
+  if (s === "hidden" || s === "collapsed" || s === "closed") return "hidden";
+  return "on";
+}
+
+function normalizeZones(raw: RawConfig["zones"] | undefined): ZonesConfig {
+  return {
+    planner: normalizeZoneMode(raw?.planner),
+    agenda: normalizeZoneMode(raw?.agenda),
+    agents: normalizeZoneMode(raw?.agents),
+  };
+}
+
 interface FoundConfig {
   path: string;
   dir: string;
@@ -239,6 +289,7 @@ function normalize(raw: Partial<RawConfig>, root: string, loaded: boolean): Conf
         ? raw.resume_command.map(String)
         : undefined,
     calendars: normalizeCalendars(raw.calendars, root),
+    zones: normalizeZones(raw.zones),
   };
 }
 

package/src/input/handleKey.ts

@@ -2,11 +2,11 @@
  * Centralized keyboard input handler. Dispatches based on:
  *   1. modal state (modal eats most keys)
  *   2. global keys (quit, help, undo, board switch, escape, zone cycle)
- *   3. active zone (virtual / board / timeline / agents)
+ *   3. active zone (planner / board / timeline / agents)
  *
  * Task-level actions (`t`/`m`/`s`/`b`/`a`/`o`/`Space`/`X`/`d`/`p`/`.`/`Enter`)
  * all route through `dispatchTaskAction`, so they work identically on a
- * cursor task whether you reach it via the kanban board, the virtual
+ * cursor task whether you reach it via the kanban board, the planner
  * panel, or a timeline block.
  *
  * Extracted from app.tsx so every root view (Dashboard, BoardOnly, etc.)
@@ -24,7 +24,7 @@ import {
 } from "~/store/index";
 import type { Board, PriorityLevel } from "~/types";
 import { buildTimelineEntries, formatAgendaDay } from "~/store/timeline";
-import { buildVirtualItems } from "~/store/virtual-panel";
+import { buildPlannerItems } from "~/store/planner-panel";
 import { jumpToKanban } from "~/ui/TimelineView";
 
 interface KeyEvent {
@@ -37,7 +37,7 @@ interface KeyEvent {
 export function handleKey(
   store: TuiStore,
   key: KeyEvent,
-  virtualCount: number,
+  plannerCount: number,
 ): void {
   const ui = store.state.ui;
   const board = store.state.boards[ui.activeBoardIndex]?.board;
@@ -125,17 +125,18 @@ export function handleKey(
     return;
   }
 
-  // F1/F2/F3 toggle zone visibility. Board cannot be hidden.
+  // F1/F2/F3 toggle zone visibility. Board cannot be hidden; a disabled zone's
+  // key is inert (toggleZoneDesired no-ops).
   if (key.name === "f1") {
-    store.setZoneVisible("virtual", !ui.visibleZones.virtual);
+    store.toggleZoneDesired("planner");
     return;
   }
   if (key.name === "f2") {
-    store.setZoneVisible("timeline", !ui.visibleZones.timeline);
+    store.toggleZoneDesired("timeline");
     return;
   }
   if (key.name === "f3") {
-    store.setZoneVisible("agents", !ui.visibleZones.agents);
+    store.toggleZoneDesired("agents");
     return;
   }
 
@@ -150,9 +151,9 @@ export function handleKey(
     return;
   }
 
-  // Switch in/out of virtual panel with `v`
+  // Switch in/out of planner panel with `v`
   if (key.name === "v") {
-    store.setActiveZone(ui.activeZone === "virtual" ? "board" : "virtual");
+    store.setActiveZone(ui.activeZone === "planner" ? "board" : "planner");
     return;
   }
 
@@ -183,7 +184,7 @@ export function handleKey(
     return;
   }
 
-  // Zoom toggle: focus the active panel (board column or virtual panel)
+  // Zoom toggle: focus the active panel (board column or planner panel)
   // at full width.
   if (key.name === "z") {
     store.toggleZoom();
@@ -227,8 +228,8 @@ export function handleKey(
 
   // ─── Per-zone dispatching ───────────────────────────────────────────────
 
-  if (ui.activeZone === "virtual") {
-    handleVirtualZone(store, key, virtualCount, openLater);
+  if (ui.activeZone === "planner") {
+    handlePlannerZone(store, key, plannerCount, openLater);
     return;
   }
 
@@ -249,19 +250,19 @@ export function handleKey(
 
 // ─── Zone handlers ──────────────────────────────────────────────────────────
 
-function handleVirtualZone(
+function handlePlannerZone(
   store: TuiStore,
   key: KeyEvent,
-  virtualCount: number,
+  plannerCount: number,
   openLater: (m: ModalKind) => void,
 ): void {
   const ui = store.state.ui;
-  const items = buildVirtualItems(store.state.boards.map((b) => b.board));
+  const items = buildPlannerItems(store.state.boards.map((b) => b.board));
   const target = items[ui.row];
 
   // Navigation
   if (key.name === "j" || key.name === "down") {
-    store.setCursor(ui.col, Math.min(virtualCount - 1, ui.row + 1));
+    store.setCursor(ui.col, Math.min(plannerCount - 1, ui.row + 1));
     return;
   }
   if (key.name === "k" || key.name === "up") {
@@ -273,7 +274,7 @@ function handleVirtualZone(
     return;
   }
 
-  // Task actions on the virtual cursor's target (works cross-board).
+  // Task actions on the planner cursor's target (works cross-board).
   if (target) {
     dispatchTaskAction(store, key, target.ref, openLater);
   }
@@ -501,7 +502,7 @@ function handleBoardZone(
     // unrendered, unscrollable column.
     const prev = adjacentVisibleColumn(store, board, ui.col, -1);
     if (prev === undefined) {
-      store.setActiveZone("virtual");
+      store.setActiveZone("planner");
     } else {
       store.setCursor(prev, 0);
     }
@@ -551,7 +552,7 @@ function handleBoardZone(
 
 /**
  * Apply a task-level action to the given cursorRef. Used by every zone
- * (board / virtual / timeline) so the keys feel identical wherever the
+ * (board / planner / timeline) so the keys feel identical wherever the
  * cursor lives. Multi-select aware: when there are marked tasks, the
  * action operates on all of them via `applyToMarkedOr`.
  *
@@ -565,7 +566,7 @@ function dispatchTaskAction(
   ref: TaskRef,
   openLater: (m: ModalKind) => void,
 ): boolean {
-  // Toggle done (Enter). Only meaningful for board/virtual; timeline has
+  // Toggle done (Enter). Only meaningful for board/planner; timeline has
   // its own Enter behavior (jump to kanban) which is handled earlier.
   if (key.name === "enter" || key.name === "return") {
     const n = store.applyToMarkedOr(ref, (r) => store.toggleDone(r));
@@ -623,7 +624,7 @@ function dispatchTaskAction(
   // Calendar arm mode (lowercase c): toggle a persistent mode for batch
   // scheduling onto the timeline. Entering also arms the cursor task and
   // focuses the timeline so you can immediately click a slot. While the mode
-  // is on, clicking ANY task (board / virtual) arms it — click a task, click a
+  // is on, clicking ANY task (board / planner) arms it — click a task, click a
   // slot, repeat. `c` again or `Esc` exits. Works from any zone.
   if (key.name === "c" && !key.shift) {
     if (store.state.ui.armMode) {

package/src/store/index.test.ts

@@ -10,7 +10,7 @@ describe("test runner smoke", () => {
 });
 
 /** Builds a minimal config with no boards — enough to exercise pure UI actions. */
-function emptyConfig(): Config {
+function emptyConfig(overrides: Partial<Config> = {}): Config {
   return {
     root: process.cwd(),
     loaded: false,
@@ -18,6 +18,8 @@ function emptyConfig(): Config {
     assignees: [],
     doneColumn: "Done",
     archiveColumn: "Archive",
+    zones: { planner: "on", agenda: "on", agents: "on" },
+    ...overrides,
   };
 }
 
@@ -29,16 +31,16 @@ describe("UI activeZone", () => {
 
   it("setActiveZone updates the zone", () => {
     const store = createTuiStore({ config: emptyConfig() });
-    store.setActiveZone("virtual");
-    expect(store.state.ui.activeZone).toBe("virtual");
+    store.setActiveZone("planner");
+    expect(store.state.ui.activeZone).toBe("planner");
     store.setActiveZone("timeline");
     expect(store.state.ui.activeZone).toBe("timeline");
   });
 
-  it("setActiveZone('virtual') resets row to 0", () => {
+  it("setActiveZone('planner') resets row to 0", () => {
     const store = createTuiStore({ config: emptyConfig() });
     store.setCursor(0, 7);
-    store.setActiveZone("virtual");
+    store.setActiveZone("planner");
     expect(store.state.ui.row).toBe(0);
   });
 });
@@ -47,7 +49,7 @@ describe("UI visibleZones", () => {
   it("defaults to all four zones visible", () => {
     const store = createTuiStore({ config: emptyConfig() });
     expect(store.state.ui.visibleZones).toEqual({
-      virtual: true,
+      planner: true,
       board: true,
       timeline: true,
       agents: true,
@@ -58,7 +60,7 @@ describe("UI visibleZones", () => {
     const store = createTuiStore({ config: emptyConfig() });
     store.setZoneVisible("timeline", false);
     expect(store.state.ui.visibleZones.timeline).toBe(false);
-    expect(store.state.ui.visibleZones.virtual).toBe(true);
+    expect(store.state.ui.visibleZones.planner).toBe(true);
     expect(store.state.ui.visibleZones.board).toBe(true);
     expect(store.state.ui.visibleZones.agents).toBe(true);
   });
@@ -80,7 +82,7 @@ describe("UI visibleZones", () => {
 describe("UI cycleActiveZone", () => {
   it("cycles through all visible zones in fixed order", () => {
     const store = createTuiStore({ config: emptyConfig() });
-    store.setActiveZone("virtual");
+    store.setActiveZone("planner");
     store.cycleActiveZone();
     expect(store.state.ui.activeZone).toBe("board");
     store.cycleActiveZone();
@@ -88,7 +90,7 @@ describe("UI cycleActiveZone", () => {
     store.cycleActiveZone();
     expect(store.state.ui.activeZone).toBe("agents");
     store.cycleActiveZone();
-    expect(store.state.ui.activeZone).toBe("virtual"); // wrap
+    expect(store.state.ui.activeZone).toBe("planner"); // wrap
   });
 
   it("skips hidden zones", () => {
@@ -101,7 +103,7 @@ describe("UI cycleActiveZone", () => {
 
   it("is a no-op when only one zone is visible (board only)", () => {
     const store = createTuiStore({ config: emptyConfig() });
-    store.setZoneVisible("virtual", false);
+    store.setZoneVisible("planner", false);
     store.setZoneVisible("timeline", false);
     store.setZoneVisible("agents", false);
     store.cycleActiveZone();
@@ -156,3 +158,67 @@ describe("Agenda day navigation", () => {
     expect(store.state.ui.row).toBe(0);
   });
 });
+
+describe("zones config", () => {
+  it("enables and shows all zones by default", () => {
+    const s = createTuiStore({ config: emptyConfig() });
+    expect(s.state.ui.enabledZones).toEqual({ board: true, planner: true, timeline: true, agents: true });
+    expect(s.state.ui.visibleZones).toEqual({ board: true, planner: true, timeline: true, agents: true });
+  });
+
+  it("disables a zone set to off (never enabled, never visible)", () => {
+    const s = createTuiStore({
+      config: emptyConfig({ zones: { planner: "on", agenda: "off", agents: "off" } }),
+    });
+    expect(s.state.ui.enabledZones.timeline).toBe(false);
+    expect(s.state.ui.enabledZones.agents).toBe(false);
+    expect(s.state.ui.visibleZones.timeline).toBe(false);
+    expect(s.state.ui.visibleZones.agents).toBe(false);
+  });
+
+  it("a hidden zone is enabled but not visible at start; F-key reveals it", () => {
+    const s = createTuiStore({
+      config: emptyConfig({ zones: { planner: "hidden", agenda: "on", agents: "on" } }),
+    });
+    expect(s.state.ui.enabledZones.planner).toBe(true);
+    expect(s.state.ui.visibleZones.planner).toBe(false);
+    s.toggleZoneDesired("planner");
+    expect(s.state.ui.visibleZones.planner).toBe(true);
+  });
+
+  it("F-key toggle is a no-op on a disabled zone", () => {
+    const s = createTuiStore({
+      config: emptyConfig({ zones: { planner: "on", agenda: "off", agents: "on" } }),
+    });
+    s.toggleZoneDesired("timeline");
+    expect(s.state.ui.visibleZones.timeline).toBe(false);
+  });
+
+  it("Shift-Tab cycle skips disabled zones", () => {
+    const s = createTuiStore({
+      config: emptyConfig({ zones: { planner: "on", agenda: "off", agents: "off" } }),
+    });
+    s.setActiveZone("board");
+    s.cycleActiveZone();
+    expect(s.state.ui.activeZone).toBe("planner");
+    s.cycleActiveZone();
+    expect(s.state.ui.activeZone).toBe("board"); // timeline + agents skipped
+  });
+
+  it("responsive fits never force-show a disabled zone", () => {
+    const s = createTuiStore({
+      config: emptyConfig({ zones: { planner: "on", agenda: "off", agents: "on" } }),
+    });
+    s.applyResponsiveFits({ planner: true, timeline: true, agents: true });
+    expect(s.state.ui.visibleZones.timeline).toBe(false); // disabled stays off
+    expect(s.state.ui.visibleZones.agents).toBe(true);
+  });
+
+  it("responsive hides a zone that doesn't fit; it returns when it fits again", () => {
+    const s = createTuiStore({ config: emptyConfig() });
+    s.applyResponsiveFits({ planner: true, timeline: false, agents: true });
+    expect(s.state.ui.visibleZones.timeline).toBe(false);
+    s.applyResponsiveFits({ planner: true, timeline: true, agents: true });
+    expect(s.state.ui.visibleZones.timeline).toBe(true);
+  });
+});

package/src/store/index.ts

@@ -8,7 +8,7 @@
  * The store also owns:
  *   - The list of loaded boards (with their original mtime watermark)
  *   - UI state: active board index, cursor (col/row), collapse flags,
- *     filter, mode (kanban / virtual / list)
+ *     filter, mode (kanban / planner / list)
  *   - The undo log
  *
  * Mutations always:
@@ -71,17 +71,28 @@ export type ModalKind =
   | { kind: "help" };
 
 /** Which dashboard zone owns the keyboard cursor. */
-export type ActiveZone = "virtual" | "board" | "timeline" | "agents";
+export type ActiveZone = "planner" | "board" | "timeline" | "agents";
 
 /** Fixed cycling order for Shift+Tab navigation. */
-const ZONE_ORDER: readonly ActiveZone[] = ["virtual", "board", "timeline", "agents"];
+const ZONE_ORDER: readonly ActiveZone[] = ["planner", "board", "timeline", "agents"];
 
 export interface UIState {
   activeBoardIndex: number;
   /** Which dashboard zone owns the keyboard cursor right now. */
   activeZone: ActiveZone;
-  /** Which zones are currently rendered. `board` cannot be hidden (load-bearing). */
+  /**
+   * Which zones are actually rendered right now. Derived from
+   * `enabledZones ∧ desiredVisible ∧ fits-at-current-width`. Read by the views;
+   * never set directly — go through setZoneVisible / toggleZoneDesired /
+   * applyResponsiveFits, which recompute it.
+   */
   visibleZones: Record<ActiveZone, boolean>;
+  /**
+   * Which zones are enabled at all (from the `zones:` config). A disabled zone
+   * is never rendered, is skipped by Shift-Tab, has an inert F-key, and its
+   * background work never started. `board` is always enabled.
+   */
+  enabledZones: Record<ActiveZone, boolean>;
   /** Column index (within active board) — meaningful only when `activeZone === "board"`. */
   col: number;
   /** Row index inside the active zone. */
@@ -109,7 +120,7 @@ export interface UIState {
   armedTimelineRef?: TaskRef;
   /**
    * Persistent calendar "arm mode" (toggled with `c`). While on, clicking any
-   * task in the board / virtual panel arms it for the timeline, so you can
+   * task in the board / planner panel arms it for the timeline, so you can
    * schedule several tasks in a row — click a task, click a slot, repeat —
    * without re-pressing `c`. `Esc` (or `c` again) exits. Distinct from
    * `armedTimelineRef`, which is the single task currently armed.
@@ -150,7 +161,7 @@ export interface StoreState {
   undo: UndoEntry[];
   /**
    * Monotonic mutation counter. Bumped on every board mutation (via
-   * `saveBoard`). Derived views (board columns, virtual panel, timeline) read
+   * `saveBoard`). Derived views (board columns, planner panel, timeline) read
    * it so their memos recompute on any change — a reliable top-level signal
    * dependency, since OpenTUI/Solid's fine-grained tracking of deeply-nested
    * store edits (e.g. growing a column's `children` array) doesn't always
@@ -169,12 +180,43 @@ export interface CreateStoreOptions {
 export function createTuiStore({ config }: CreateStoreOptions) {
   const initialBoards = loadAll(config);
 
+  // ─── Zone enablement (from `zones:` config) ──────────────────────────────
+  // `enabledZones` is a hard gate; `desiredVisible` is the user's runtime
+  // intent (F-keys flip it); `lastFits` is the terminal-width fit cache. The
+  // rendered `visibleZones` is the AND of all three. The board is always on.
+  const z = config.zones;
+  const enabledZones: Record<ActiveZone, boolean> = {
+    board: true,
+    planner: z.planner !== "off",
+    timeline: z.agenda !== "off",
+    agents: z.agents !== "off",
+  };
+  const desiredVisible: Record<ActiveZone, boolean> = {
+    board: true,
+    planner: z.planner === "on",
+    timeline: z.agenda === "on",
+    agents: z.agents === "on",
+  };
+  let lastFits: Record<ActiveZone, boolean> = {
+    board: true,
+    planner: true,
+    timeline: true,
+    agents: true,
+  };
+  const computeVisible = (): Record<ActiveZone, boolean> => ({
+    board: true,
+    planner: enabledZones.planner && desiredVisible.planner && lastFits.planner,
+    timeline: enabledZones.timeline && desiredVisible.timeline && lastFits.timeline,
+    agents: enabledZones.agents && desiredVisible.agents && lastFits.agents,
+  });
+
   const [state, setState] = createStore<StoreState>({
     boards: initialBoards,
     ui: {
       activeBoardIndex: 0,
       activeZone: "board",
-      visibleZones: { virtual: true, board: true, timeline: true, agents: true },
+      visibleZones: computeVisible(),
+      enabledZones,
       col: 0,
       row: 0,
       zoomed: false,
@@ -198,11 +240,17 @@ export function createTuiStore({ config }: CreateStoreOptions) {
   );
 
   // Agents store has its own lifecycle (chokidar watcher on ~/.claude).
-  // Shared dispose() boundary below so SIGINT cleans both.
-  const agentsStore: AgentsStore = createAgentsStore();
-  // Calendar feeds (read-only) merged into the Agenda zone. No-op when no
-  // `calendars:` block is configured.
-  const calendarStore: CalendarStore = createCalendarStore(config.calendars, isoToday);
+  // Shared dispose() boundary below so SIGINT cleans both. When the agents
+  // zone is disabled we skip the watcher entirely (no `~/.claude` reads at all)
+  // and hand back an inert stub.
+  const agentsStore: AgentsStore = enabledZones.agents
+    ? createAgentsStore()
+    : noopAgentsStore();
+  // Calendar feeds (read-only) merged into the Agenda zone. Skipped entirely
+  // (no network) when the agenda zone is disabled.
+  const calendarStore: CalendarStore = enabledZones.timeline
+    ? createCalendarStore(config.calendars, isoToday)
+    : noopCalendarStore();
   watcher.onChange((filepath) => {
     // External edit. Re-read this board from disk.
     try {
@@ -716,19 +764,46 @@ export function createTuiStore({ config }: CreateStoreOptions) {
 
   function setActiveZone(zone: ActiveZone): void {
     setState("ui", "activeZone", zone);
-    // Moving to a vertical-list zone (virtual / agents / timeline) resets
+    // Moving to a vertical-list zone (planner / agents / timeline) resets
     // the row cursor to the top so the user always lands somewhere sensible.
     if (zone !== "board") setState("ui", "row", 0);
   }
 
+  /** Recompute `visibleZones` from enabled ∧ desired ∧ fits; bounce the cursor
+   *  to the board if the active zone just became invisible. */
+  function recomputeVisible(): void {
+    const v = computeVisible();
+    setState("ui", "visibleZones", v);
+    if (!v[state.ui.activeZone]) setActiveZone("board");
+  }
+
+  /** Set a zone's desired visibility (user intent). Showing a disabled zone is
+   *  ignored; the board can never be hidden. Used by direct reveals (day-nav,
+   *  arm flow) and the responsive layout's per-zone calls. */
   function setZoneVisible(zone: ActiveZone, visible: boolean): void {
-    // Board is the load-bearing zone — never allow it to be hidden.
     if (zone === "board" && !visible) return;
-    setState("ui", "visibleZones", zone, visible);
-    // If we just hid the active zone, bounce the cursor to "board".
-    if (!visible && state.ui.activeZone === zone) {
-      setActiveZone("board");
-    }
+    if (visible && !enabledZones[zone]) return; // can't reveal a disabled zone
+    desiredVisible[zone] = visible;
+    recomputeVisible();
+  }
+
+  /** Flip a zone's visibility (the F1/F2/F3 toggles). No-op if disabled. */
+  function toggleZoneDesired(zone: ActiveZone): void {
+    if (zone === "board" || !enabledZones[zone]) return;
+    desiredVisible[zone] = !desiredVisible[zone];
+    recomputeVisible();
+  }
+
+  /** Update the terminal-width fit cache (called by the responsive layout) and
+   *  recompute. Never overrides enablement or the user's desired visibility. */
+  function applyResponsiveFits(fits: Partial<Record<ActiveZone, boolean>>): void {
+    lastFits = {
+      board: true,
+      planner: fits.planner !== false,
+      timeline: fits.timeline !== false,
+      agents: fits.agents !== false,
+    };
+    recomputeVisible();
   }
 
   function cycleActiveZone(): void {
@@ -1034,6 +1109,8 @@ export function createTuiStore({ config }: CreateStoreOptions) {
     setCursor,
     setActiveZone,
     setZoneVisible,
+    toggleZoneDesired,
+    applyResponsiveFits,
     cycleActiveZone,
     toggleZoom,
     toggleGrab,
@@ -1069,6 +1146,22 @@ export type TuiStore = ReturnType<typeof createTuiStore>;
 
 // ─── Load helpers ────────────────────────────────────────────────────────────
 
+/** Inert agents store for when the agents zone is disabled — no chokidar
+ *  watcher, no `~/.claude` reads at all. */
+function noopAgentsStore(): AgentsStore {
+  return { sessions: () => [], refresh: () => {}, dispose: async () => {} };
+}
+
+/** Inert calendar store for when the agenda zone is disabled — no fetching. */
+function noopCalendarStore(): CalendarStore {
+  return {
+    events: () => [],
+    setActiveDate: () => {},
+    refresh: () => {},
+    dispose: async () => {},
+  };
+}
+
 function loadAll(config: Config): LoadedBoard[] {
   const out: LoadedBoard[] = [];
   for (const b of config.boards) {

package/src/ui/AgentsBar.tsx

@@ -1,7 +1,7 @@
 /**
  * Compact agent status strip for the dashboard. The non-archived sessions
  * render inside a vertical scrollbox so the list scrolls with the mouse wheel
- * (like the board / virtual / timeline zones) AND follows the keyboard cursor
+ * (like the board / planner / timeline zones) AND follows the keyboard cursor
  * via scrollChildIntoView — same pattern as BoardView's columns.
  *
  * The border color reflects activeZone === "agents" so the cursor ring is

package/src/ui/BoardView.tsx

@@ -1,7 +1,7 @@
 /**
  * Kanban board view — horizontal scrolling row of full-height columns.
  *
- * Mirrors the Today/Tomorrow virtual panel: each column has a fixed width
+ * Mirrors the Today/Tomorrow planner panel: each column has a fixed width
  * and stretches vertically to fill the board area. Columns that don't fit
  * the available horizontal space are reached via horizontal scroll. Zoom
  * mode collapses everything down to the single active column at full
@@ -88,7 +88,7 @@ export function BoardView(props: BoardViewProps) {
    * (Python kanban `z`).
    */
   const renderedColumns = createMemo(() => {
-    if (!ui().zoomed || ui().activeZone === "virtual") return visibleColumns();
+    if (!ui().zoomed || ui().activeZone === "planner") return visibleColumns();
     const cols = visibleColumns();
     // ui.col is a board.columns index (carries Archive); map it to the
     // rendered list so zoom focuses the column actually under the cursor.
@@ -111,7 +111,7 @@ export function BoardView(props: BoardViewProps) {
   // geometry used everywhere (COL_WIDTH + COL_GAP).
   createEffect(() => {
     const colIdx = ui().col;
-    if (ui().zoomed || ui().activeZone === "virtual") {
+    if (ui().zoomed || ui().activeZone === "planner") {
       setScrollX(0);
       return;
     }
@@ -153,7 +153,7 @@ export function BoardView(props: BoardViewProps) {
   };
 
   // Measure the viewport width once at mount, regardless of the active zone.
-  // Otherwise — since tuiboard now starts focused on the virtual panel — the
+  // Otherwise — since tuiboard now starts focused on the planner panel — the
   // scroll effect early-returns and viewportW stays 0, so partly-clipped
   // columns briefly show their task rows until the board is first touched.
   onMount(() => {
@@ -328,7 +328,7 @@ function ColumnView(props: ColumnViewProps) {
         flexShrink: 0,
         // No explicit height — Yoga stretches us along the row's cross
         // axis, so the column always fills the full board height. Same
-        // contract as the Today/Tomorrow virtual panel next door.
+        // contract as the Today/Tomorrow planner panel next door.
         marginRight: COL_GAP,
         border: true,
         borderStyle: "rounded",

package/src/ui/Modal.tsx

@@ -588,12 +588,12 @@ function HelpModal(props: { store: TuiStore }) {
         <span style={{ fg: T.text }}>{"  h j k l  ←↑↓→     Move cursor inside the active zone\n"}</span>
         <span style={{ fg: T.text }}>{"  Tab               Next board (kanban zone)\n"}</span>
         <span style={{ fg: T.text }}>{"  1..9              Jump to board N\n"}</span>
-        <span style={{ fg: T.text }}>{"  v                 Toggle Today/Tomorrow virtual panel focus\n"}</span>
-        <span style={{ fg: T.text }}>{"  Shift-Tab         Cycle active zone (virtual → board → timeline → agents)\n"}</span>
-        <span style={{ fg: T.text }}>{"  F1 / F2 / F3      Toggle visibility of Virtual / Timeline / Agents zones\n"}</span>
+        <span style={{ fg: T.text }}>{"  v                 Toggle Today/Tomorrow planner panel focus\n"}</span>
+        <span style={{ fg: T.text }}>{"  Shift-Tab         Cycle active zone (planner → board → timeline → agents)\n"}</span>
+        <span style={{ fg: T.text }}>{"  F1 / F2 / F3      Toggle visibility of Planner / Timeline / Agents zones\n"}</span>
         <span style={{ fg: T.text }}>{"  z                 Zoom active zone (or column) to full screen\n"}</span>
         <span style={{ fg: T.text }}>{"  r                 Refresh everything (boards from disk, agents, agenda calendar)\n"}</span>
-        <span style={{ fg: T.textDim }}>{"\nTask actions (work in board, virtual, AND timeline zones)\n"}</span>
+        <span style={{ fg: T.textDim }}>{"\nTask actions (work in board, planner, AND timeline zones)\n"}</span>
         <span style={{ fg: T.text }}>{"  Enter             Toggle done\n"}</span>
         <span style={{ fg: T.text }}>{"  o                 Open detail view\n"}</span>
         <span style={{ fg: T.text }}>{"  e                 Edit task text\n"}</span>

package/src/ui/{VirtualPanel.tsx → PlannerPanel.tsx}

@@ -1,14 +1,14 @@
-/** The fixed Today/Tomorrow virtual panel — always on the left. */
+/** The fixed Today/Tomorrow planner panel — always on the left. */
 
 import { For, Show, createEffect, createMemo } from "solid-js";
 
 import { ATTR, T } from "~/ui/glyphs";
 import { TaskRow } from "~/ui/TaskRow";
 import {
-  buildVirtualItems,
-  groupVirtualItems,
-  type VirtualGroup,
-} from "~/store/virtual-panel";
+  buildPlannerItems,
+  groupPlannerItems,
+  type PlannerGroup,
+} from "~/store/planner-panel";
 import type { TuiStore } from "~/store/index";
 
 interface ScrollBoxLike {
@@ -32,15 +32,15 @@ const BUCKET_HEADER: Record<string, { label: string; color: string }> = {
   priority: { label: "🔺 Priority", color: T.today },
 };
 
-export function VirtualPanel(props: { store: TuiStore }) {
+export function PlannerPanel(props: { store: TuiStore }) {
   const items = createMemo(() => {
     props.store.state.rev; // recompute on any board mutation
-    return buildVirtualItems(props.store.state.boards.map((b) => b.board));
+    return buildPlannerItems(props.store.state.boards.map((b) => b.board));
   });
-  const groups = createMemo(() => groupVirtualItems(items()));
-  const isActive = createMemo(() => props.store.state.ui.activeZone === "virtual");
+  const groups = createMemo(() => groupPlannerItems(items()));
+  const isActive = createMemo(() => props.store.state.ui.activeZone === "planner");
   const isZoomed = createMemo(
-    () => props.store.state.ui.zoomed && props.store.state.ui.activeZone === "virtual",
+    () => props.store.state.ui.zoomed && props.store.state.ui.activeZone === "planner",
   );
   const cursorRow = createMemo(() => props.store.state.ui.row);
   let scrollBoxRef: ScrollBoxLike | undefined;
@@ -121,7 +121,7 @@ export function VirtualPanel(props: { store: TuiStore }) {
             availableWidth={isZoomed() ? 100 : 36}
             isMarkedFn={(r) => props.store.isMarked(r)}
             onClickItem={(flatIndex) => {
-              props.store.setActiveZone("virtual");
+              props.store.setActiveZone("planner");
               props.store.setCursor(0, flatIndex);
               // In calendar arm mode, a click also arms the task for the
               // timeline (click a task, then a slot to place it).
@@ -141,7 +141,7 @@ export function VirtualPanel(props: { store: TuiStore }) {
 }
 
 function RenderGroups(props: {
-  groups: VirtualGroup[];
+  groups: PlannerGroup[];
   isActive: boolean;
   cursorRow: number;
   availableWidth: number;
@@ -258,7 +258,7 @@ function RenderGroups(props: {
 }
 
 function isFirstOfSection(
-  groups: VirtualGroup[],
+  groups: PlannerGroup[],
   idx: number,
 ): boolean {
   if (idx === 0) return true;

package/src/ui/TimelineView.tsx

@@ -354,7 +354,7 @@ export function TimelineView(props: TimelineViewProps) {
       </Show>
 
       {/* The 24h grid now owns the whole panel — no sticky section above
-          it. Tasks are armed for scheduling from the board / virtual panel
+          it. Tasks are armed for scheduling from the board / planner panel
           via the `C` shortcut, then placed by clicking a slot here. */}
       <scrollbox
         ref={(r: ScrollBoxLike) => (scrollBoxRef = r)}

package/src/ui/glyphs.ts

@@ -29,7 +29,7 @@ export const ATTR = {
  *    instead of raw ANSI names like "red"/"yellow" — those tend to render
  *    as fully-saturated traffic-light colors in most themes and clash
  *    with everything around them.
- *  - The Today/Tomorrow virtual panel has its own *warm* identity
+ *  - The Today/Tomorrow planner panel has its own *warm* identity
  *    (peach/orange) so the user instantly knows "this is the time zone";
  *    everything else uses a *cool* identity (soft cyan) for active focus.
  *  - Cursor row highlight is the only opaque paint outside the modal.
@@ -137,7 +137,7 @@ export function cellWidth(s: string): number {
 }
 
 /**
- * Per-board accent palette. Used by the virtual panel to color-code the
+ * Per-board accent palette. Used by the planner panel to color-code the
  * source-board tag on priority/agenda items, so the user can recognize
  * which board a cross-cutting item came from at a glance.
  *

package/src/views/BoardOnly.tsx

@@ -1,5 +1,5 @@
 /**
- * Standalone fullscreen view for the kanban board (with virtual panel).
+ * Standalone fullscreen view for the kanban board (with planner panel).
  * Mounted when the user launches `tuiboard --view=board`, AND used inside
  * the dashboard via composition.
  *
@@ -13,7 +13,7 @@
 import { Show, createMemo } from "solid-js";
 
 import { BoardView } from "~/ui/BoardView";
-import { VirtualPanel } from "~/ui/VirtualPanel";
+import { PlannerPanel } from "~/ui/PlannerPanel";
 import type { TuiStore } from "~/store/index";
 
 export function BoardOnly(props: { store: TuiStore }) {
@@ -24,10 +24,10 @@ export function BoardOnly(props: { store: TuiStore }) {
 
   return (
     <box style={{ flexDirection: "row", flexGrow: 1 }}>
-      <Show when={!ui().zoomed || ui().activeZone === "virtual"}>
-        <VirtualPanel store={props.store} />
+      <Show when={!ui().zoomed || ui().activeZone === "planner"}>
+        <PlannerPanel store={props.store} />
       </Show>
-      <Show when={(!ui().zoomed || ui().activeZone !== "virtual") && activeBoard()}>
+      <Show when={(!ui().zoomed || ui().activeZone !== "planner") && activeBoard()}>
         <BoardView store={props.store} board={activeBoard()!} />
       </Show>
     </box>

package/src/views/Dashboard.tsx

@@ -1,7 +1,7 @@
 /**
  * The default tuiboard view: a 4-zone dashboard.
  *
- *   ┌─Virtual─┬─Board────────┬─Timeline─┐
+ *   ┌─Planner─┬─Board────────┬─Timeline─┐
  *   │         │              │          │
  *   │         │              │          │
  *   │         ├──────────────┤          │
@@ -24,7 +24,7 @@ import { Show, createMemo } from "solid-js";
 import { AgentsBar } from "~/ui/AgentsBar";
 import { BoardView } from "~/ui/BoardView";
 import { TimelineView } from "~/ui/TimelineView";
-import { VirtualPanel } from "~/ui/VirtualPanel";
+import { PlannerPanel } from "~/ui/PlannerPanel";
 import { AgentsOnly } from "~/views/AgentsOnly";
 import { BoardOnly } from "~/views/BoardOnly";
 import { TimelineOnly } from "~/views/TimelineOnly";
@@ -53,7 +53,7 @@ export function Dashboard(props: { store: TuiStore }) {
  * standalone view wrappers so a `z` press in the dashboard produces
  * the same visual as launching `tuiboard --view=<zone>`.
  *
- * Board + virtual share BoardOnly because both live in the top-left
+ * Board + planner share BoardOnly because both live in the top-left
  * zone of the normal layout and BoardOnly already respects ui.zoomed
  * to render only the active panel between them.
  */
@@ -80,12 +80,12 @@ function FourZoneLayout(props: { store: TuiStore }) {
 
   return (
     <box style={{ flexDirection: "row", flexGrow: 1 }}>
-      {/* Left column: virtual + board on top, agents on bottom */}
+      {/* Left column: planner + board on top, agents on bottom */}
       <box style={{ flexDirection: "column", flexGrow: 1 }}>
         {/* Top zone */}
         <box style={{ flexDirection: "row", flexGrow: 1 }}>
-          <Show when={visible().virtual}>
-            <VirtualPanel store={props.store} />
+          <Show when={visible().planner}>
+            <PlannerPanel store={props.store} />
           </Show>
           <Show when={visible().board && activeBoard()}>
             <BoardView store={props.store} board={activeBoard()!} />