tuiboard 0.5.0 → 0.5.1

package/.tuiboard/config.example.yaml

@@ -30,3 +30,20 @@ done_column: Done
 # Name of the column used by the archive action (Shift-X). If the column
 # doesn't exist in a board, tuiboard creates it on the fly.
 archive_column: Archive
+
+# 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
+# to spawn a custom terminal layout. When omitted, tuiboard just opens a new
+# WezTerm tab and runs `claude --resume <sessionId>`.
+#
+# 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
+# and Windows App Execution Aliases (e.g. a Store-installed `pwsh`) won't
+# resolve; use a real binary like `nu`, `python`, or a full path instead.
+#
+# resume_command:
+#   - nu
+#   - C:/Users/you/.config/tuiboard/code-resume.nu
+#   - "{cwd}"
+#   - "{sessionId}"

package/README.md

@@ -78,6 +78,12 @@ boards:
 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:
+# resume_command: ["nu", "C:/Users/you/.config/tuiboard/code-resume.nu", "{cwd}", "{sessionId}"]
 ```
 
 ## Markdown board format
@@ -176,6 +182,8 @@ session (until the next terminal resize).
 | `b` | Set time block modal |
 | `p` | Cycle priority (none → 🔺 → ⏫ → 🔼 → 🔽 → ⏬ → none) |
 | `a` | Set assignee |
+| `c` | Toggle calendar **arm mode** — then click a task, click a timeline slot, repeat |
+| `Shift-C` | Copy task to clipboard (markdown line — paste as context for Claude Code) |
 | `d` | Delete task (with confirm) |
 | `Shift-X` | Archive task → moves to Archive column |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tuiboard",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "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/config/loader.ts

@@ -34,6 +34,15 @@ export interface Config {
   assignees: string[];
   doneColumn: string;
   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
+   * 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>`.
+   */
+  resumeCommand?: string[];
 }
 
 export const DEFAULT_CONFIG: Omit<Config, "root" | "loaded" | "boards"> = {
@@ -81,6 +90,7 @@ interface RawConfig {
   assignees: string[];
   done_column: string;
   archive_column: string;
+  resume_command: string[];
 }
 
 interface FoundConfig {
@@ -144,6 +154,10 @@ function normalize(raw: Partial<RawConfig>, root: string, loaded: boolean): Conf
     assignees: raw.assignees ?? DEFAULT_CONFIG.assignees,
     doneColumn: raw.done_column ?? DEFAULT_CONFIG.doneColumn,
     archiveColumn: raw.archive_column ?? DEFAULT_CONFIG.archiveColumn,
+    resumeCommand:
+      Array.isArray(raw.resume_command) && raw.resume_command.length > 0
+        ? raw.resume_command.map(String)
+        : undefined,
   };
 }
 

package/src/input/handleKey.ts

@@ -74,11 +74,14 @@ export function handleKey(
     return;
   }
 
-  // Escape priority: timeline arm → grab mode → marks. Most disruptive first.
+  // Escape priority: arm mode / timeline arm → grab mode → marks. Most
+  // disruptive first.
   if (key.name === "escape") {
-    if (ui.armedTimelineRef) {
+    if (ui.armMode || ui.armedTimelineRef) {
+      const wasMode = ui.armMode;
+      store.setArmMode(false);
       store.armTimeline(undefined);
-      store.flashBanner("info", "Disarmed");
+      store.flashBanner("info", wasMode ? "Arm mode off" : "Disarmed");
       return;
     }
     if (ui.grabbing) {
@@ -330,11 +333,12 @@ function handleAgentsZone(store: TuiStore, key: KeyEvent): void {
     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" ||
-    key.name === "o"
-  ) {
+  } else if (key.name === "enter" || key.name === "return") {
+    // Open (resume) the selected session in a new WezTerm tab.
+    const target = sessions[ui.row];
+    if (target) void openSessionInWezterm(store, target.cwd, target.sessionId);
+  } else if (key.name === "o") {
+    // Inspect the session in the detail modal.
     const target = sessions[ui.row];
     if (target) {
       setTimeout(
@@ -559,12 +563,34 @@ function dispatchTaskAction(
     return true;
   }
 
-  // Calendar-arm (Shift+C): arm this task for the timeline and jump focus
-  // there so the user can immediately click a slot to place it. Works from
-  // the board, the virtual panel, or the timeline — wherever the cursor is.
-  // Replaces the removed sticky 'Unscheduled' list: instead of duplicating
-  // today's tasks at the top of the timeline, arm one in place and drop it.
+  // Copy task as a markdown line to the system clipboard (Shift+C). Mirrors
+  // Python kanban `action_copy_context`. Single-task only. Moved to Shift+C so
+  // lowercase `c` is free for calendar arm mode (below); Ctrl+C can't be used
+  // (it quits / is terminal-reserved), so Shift+C is the copy combo.
   if (key.name === "C" || (key.name === "c" && key.shift)) {
+    const t = store.getTask(ref);
+    if (t) {
+      copyToClipboard(t.rawLine).then(
+        () => store.flashBanner("info", "📋 Copied task"),
+        (err) => store.flashBanner("error", `Copy failed: ${err}`),
+      );
+    }
+    return true;
+  }
+
+  // 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
+  // slot, repeat. `c` again or `Esc` exits. Works from any zone.
+  if (key.name === "c" && !key.shift) {
+    if (store.state.ui.armMode) {
+      store.setArmMode(false);
+      store.armTimeline(undefined);
+      store.flashBanner("info", "Arm mode off");
+      return true;
+    }
+    store.setArmMode(true);
     store.armTimeline(ref);
     store.setZoneVisible("timeline", true);
     store.setActiveZone("timeline");
@@ -572,27 +598,12 @@ function dispatchTaskAction(
     store.flashBanner(
       "info",
       t
-        ? `⤤ Armed "${t.displayTitle.slice(0, 32)}" — click a timeline slot to place`
-        : "⤤ Armed — click a timeline slot to place",
+        ? `◉ Arm mode — armed "${t.displayTitle.slice(0, 28)}". Click a task, then a slot. Esc to exit.`
+        : "◉ Arm mode — click a task, then a slot. Esc to exit.",
     );
     return true;
   }
 
-  // Copy task as a markdown line to the system clipboard. Mirrors Python
-  // kanban `action_copy_context`. Single-task only (multi-select would
-  // require deciding how to join lines). Explicitly non-shift so Shift+C
-  // (calendar-arm, above) doesn't also trigger a clipboard copy.
-  if (key.name === "c" && !key.shift) {
-    const t = store.getTask(ref);
-    if (t) {
-      copyToClipboard(t.rawLine).then(
-        () => store.flashBanner("info", "📋 Copied task"),
-        (err) => store.flashBanner("error", `Copy failed: ${err}`),
-      );
-    }
-    return true;
-  }
-
   // Toggle priority — cycle: none → highest → high → medium → low → lowest → none.
   // Mirrors Python kanban `action_toggle_priority`.
   if (key.name === "p") {
@@ -682,6 +693,85 @@ function fmtHm(m: number): string {
   return `${h.toString().padStart(2, "0")}:${mm.toString().padStart(2, "0")}`;
 }
 
+/**
+ * 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.
+ */
+async function openSessionInWezterm(
+  store: TuiStore,
+  cwd: string,
+  sessionId: string,
+): Promise<void> {
+  const { spawn, spawnSync } = await import("node:child_process");
+
+  // 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.
+  const custom = store.config.resumeCommand;
+  if (custom && custom.length > 0) {
+    const argv = custom.map((arg) =>
+      arg.replaceAll("{cwd}", cwd).replaceAll("{sessionId}", sessionId),
+    );
+    const [cmd, ...rest] = argv;
+    try {
+      // windowsHide suppresses the transient console window the orchestrator
+      // process would otherwise flash on Windows (the equivalent of Python's
+      // CREATE_NO_WINDOW).
+      const child = spawn(cmd!, rest, {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+      });
+      child.on("error", (e: NodeJS.ErrnoException) =>
+        store.flashBanner("error", `resume_command failed: ${e.message}`),
+      );
+      child.unref();
+      store.flashBanner("info", `↗ Opening session (${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 },
+    );
+    store.flashBanner("info", `↗ Opened session in WezTerm (${sessionId.slice(0, 8)})`);
+  } catch (e) {
+    store.flashBanner("error", `WezTerm launch failed: ${String(e)}`);
+  }
+}
+
 /**
  * Cross-platform clipboard copy. Picks the host's native cli tool:
  *   Windows  → clip

package/src/store/index.ts

@@ -106,6 +106,14 @@ export interface UIState {
    * cancels.
    */
   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
+   * 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.
+   */
+  armMode: boolean;
   view: ViewMode;
   /**
    * Tasks marked for bulk ops (`Space`). Key format:
@@ -154,6 +162,7 @@ export function createTuiStore({ config }: CreateStoreOptions) {
       row: 0,
       zoomed: false,
       grabbing: false,
+      armMode: false,
       view: "kanban",
       marked: {},
       filter: "all",
@@ -738,6 +747,10 @@ export function createTuiStore({ config }: CreateStoreOptions) {
     setState("ui", "armedTimelineRef", ref);
   }
 
+  function setArmMode(on: boolean): void {
+    setState("ui", "armMode", on);
+  }
+
   // ─── Multi-select ────────────────────────────────────────────────────────
 
   function markKey(ref: TaskRef): string {
@@ -914,6 +927,7 @@ export function createTuiStore({ config }: CreateStoreOptions) {
     toggleGrab,
     exitGrab,
     armTimeline,
+    setArmMode,
     setFilter,
     applyBoardFilter,
     setZoomed,

package/src/store/timeline.test.ts

@@ -73,7 +73,7 @@ describe("buildTimelineEntries", () => {
     expect(entries[0]!.endRow).toBe(14);
   });
 
-  it("excludes done tasks", () => {
+  it("includes done tasks (timeline doubles as a done-log)", () => {
     const t = makeTask({
       displayTitle: "done deal",
       done: true,
@@ -81,7 +81,9 @@ describe("buildTimelineEntries", () => {
       timeBlock: { startMin: 9 * 60, endMin: 10 * 60 },
     });
     const board = makeBoard("R3PLICA", "r3.md", [t]);
-    expect(buildTimelineEntries([board], today)).toEqual([]);
+    const entries = buildTimelineEntries([board], today);
+    expect(entries).toHaveLength(1);
+    expect(entries[0]!.task.done).toBe(true);
   });
 
   it("excludes tasks scheduled for a different date", () => {

package/src/store/timeline.ts

@@ -70,12 +70,15 @@ export interface BuildRowMapResult {
 
 /**
  * Build the flat list of time-blocked tasks for the given ISO date.
- * Tasks must be:
- *   - non-done
+ * Tasks must:
  *   - have task.timeBlock
  *   - have task.scheduled === date (we ignore `due` for now; calendar-style
  *     time-blocking is always scheduled, not due)
  *
+ * Completed tasks ARE included (rendered green + checked) so the timeline
+ * doubles as a record of what actually got done in each slot, not just what's
+ * still pending.
+ *
  * Sorted ascending by startMin so head/body/fill rendering can claim rows
  * in chronological order.
  */
@@ -93,7 +96,8 @@ export function buildTimelineEntries(
         if (!isTask(child)) continue;
         const idx = taskIndex++;
         const t = child;
-        if (t.done) continue;
+        // Done tasks stay on the timeline (shown green + checked) — the day's
+        // schedule is also a log of what got done.
         if (!t.timeBlock) continue;
         if (t.scheduled !== date) continue;
 

package/src/ui/AgentsBar.tsx

@@ -1,62 +1,55 @@
 /**
- * Compact agent status strip for the dashboard. Renders a windowed slice
- * of the non-archived sessions list so the cursor stays inside the view
- * even when the underlying list is far larger than the visible rows.
+ * 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
+ * via scrollChildIntoView — same pattern as BoardView's columns.
  *
- * The border color reflects activeZone === "agents" so the cursor
- * ring is visible. Clicking a row sets activeZone + agent cursor.
+ * The border color reflects activeZone === "agents" so the cursor ring is
+ * visible. Clicking a row sets activeZone + agent cursor.
  */
 
-import { For, Show, createMemo } from "solid-js";
+import { For, Show, createEffect, createMemo } from "solid-js";
 
 import { AgentRow } from "~/ui/AgentRow";
 import { T } from "~/ui/glyphs";
 import type { TuiStore } from "~/store/index";
 
+interface ScrollBoxLike {
+  scrollChildIntoView(id: string): void;
+}
+
+const AGENT_ROW_PREFIX = "tuiboard-agent-row-";
+const agentRowId = (index: number) => `${AGENT_ROW_PREFIX}${index}`;
+
 interface AgentsBarProps {
   store: TuiStore;
   /** Fixed row height in the dashboard layout. */
   height?: number;
-  /** Max sessions to show in the compact strip. Default 5 (fits in height=7). */
-  maxVisible?: number;
-}
-
-interface WindowedEntry {
-  index: number;
-  // We don't import AgentSession here; carrying through the For element is fine.
-  // Solid will infer the type.
-  session: ReturnType<TuiStore["agents"]["sessions"]>[number];
 }
 
 export function AgentsBar(props: AgentsBarProps) {
   const isActive = () => props.store.state.ui.activeZone === "agents";
   const agentRow = () => props.store.state.ui.row;
-  const maxVisible = () => props.maxVisible ?? 5;
 
-  /** All visible (non-archived) sessions — full list. */
+  /** All visible (non-archived) sessions. */
   const allShown = createMemo(() =>
     props.store.agents.sessions().filter((s) => s.status !== "archived"),
   );
 
-  /**
-   * Windowed slice that follows the cursor. When the cursor falls outside
-   * the current window, we slide so it sits in the middle (when possible).
-   */
-  const windowed = createMemo<WindowedEntry[]>(() => {
-    const all = allShown();
-    const max = maxVisible();
-    if (all.length <= max) {
-      return all.map((session, index) => ({ index, session }));
-    }
-    const cursor = isActive() ? agentRow() : 0;
-    const halfWin = Math.floor(max / 2);
-    let start = Math.max(0, cursor - halfWin);
-    let end = Math.min(all.length, start + max);
-    if (end - start < max) start = Math.max(0, end - max);
-    return all.slice(start, end).map((session, i) => ({
-      index: start + i,
-      session,
-    }));
+  let scrollBoxRef: ScrollBoxLike | undefined;
+
+  // Keep the cursor row visible as j/k moves it (mouse wheel scrolls freely
+  // via the scrollbox itself). setTimeout(0) waits for layout to commit.
+  createEffect(() => {
+    const row = agentRow();
+    if (!isActive() || !scrollBoxRef) return;
+    setTimeout(() => {
+      try {
+        scrollBoxRef?.scrollChildIntoView(agentRowId(row));
+      } catch {
+        // Child not mounted yet — harmless.
+      }
+    }, 0);
   });
 
   return (
@@ -83,19 +76,34 @@ export function AgentsBar(props: AgentsBarProps) {
           </text>
         }
       >
-        <For each={windowed()}>
-          {(entry) => (
-            <AgentRow
-              session={entry.session}
-              cursor={isActive() && entry.index === agentRow()}
-              nameMaxChars={48}
-              onClick={() => {
-                props.store.setActiveZone("agents");
-                props.store.setCursor(0, entry.index);
-              }}
-            />
-          )}
-        </For>
+        <scrollbox
+          ref={(r: ScrollBoxLike) => (scrollBoxRef = r)}
+          style={{
+            width: "100%",
+            flexGrow: 1,
+            scrollX: false,
+            scrollY: true,
+            rootOptions: {},
+            contentOptions: {},
+            scrollbarOptions: { visible: false },
+          }}
+        >
+          <For each={allShown()}>
+            {(session, i) => (
+              <box id={agentRowId(i())}>
+                <AgentRow
+                  session={session}
+                  cursor={isActive() && i() === agentRow()}
+                  nameMaxChars={48}
+                  onClick={() => {
+                    props.store.setActiveZone("agents");
+                    props.store.setCursor(0, i());
+                  }}
+                />
+              </box>
+            )}
+          </For>
+        </scrollbox>
       </Show>
     </box>
   );

package/src/ui/BoardView.tsx

@@ -306,6 +306,12 @@ function ColumnView(props: ColumnViewProps) {
                   onClick={() => {
                     props.store.setActiveZone("board");
                     props.store.setCursor(props.columnIndex, ri());
+                    // In calendar arm mode, a click also arms the task so the
+                    // user can immediately drop it on a timeline slot.
+                    if (props.store.state.ui.armMode) {
+                      props.store.armTimeline(ref);
+                      props.store.setZoneVisible("timeline", true);
+                    }
                   }}
                 />
               </box>

package/src/ui/Chrome.tsx

@@ -111,9 +111,15 @@ export function BottomBar(props: { store: TuiStore }) {
         </Show>
       </box>
       <box style={{ height: 1, flexDirection: "row" }}>
-        <text>
+        {/*
+          Curated cheat-sheet: only the keys that keep you unstuck (move,
+          switch zone/board, help, quit) plus the highest-frequency, on-brand
+          actions (done, new, schedule). Everything else — zoom, toggles,
+          multi-select, edit/assign/archive/delete, undo — lives in `?`.
+        */}
+        <text wrapMode="none" truncate>
           <span style={{ fg: T.textDim }}>
-            {"hjkl move · Tab/1-9 board · S-Tab zone · F1/F2/F3 toggle · v panel · z zoom · Space mark · ⏎ done · o detail · n/e/s/b/a/X act · d del · ⌃Z undo · ? help · q quit"}
+            {"hjkl move · Tab board · ⇧Tab zone · ⏎ done · n new · c schedule · ? help · q quit"}
           </span>
         </text>
       </box>

package/src/ui/Modal.tsx

@@ -525,7 +525,9 @@ function AgentDetailModal(props: { store: TuiStore; modal: Extract<NonNullable<T
             </Show>
             <box style={{ height: 1 }} />
             <text>
-              <span style={{ fg: T.textDim }}>resume command (copy by hand for now):</span>
+              <span style={{ fg: T.textDim }}>
+                resume — press Enter in the agents list to open this in WezTerm:
+              </span>
             </text>
             <text wrapMode="word">
               <span style={{ fg: T.scheduled }}>
@@ -573,22 +575,24 @@ function HelpModal(props: { store: TuiStore }) {
         <span style={{ fg: T.text }}>{"  a                 Set assignee\n"}</span>
         <span style={{ fg: T.text }}>{"  d                 Delete task (with confirm)\n"}</span>
         <span style={{ fg: T.text }}>{"  X                 Archive task → moves to Archive column\n"}</span>
-        <span style={{ fg: T.text }}>{"  c                 Copy task to clipboard (markdown line)\n"}</span>
-        <span style={{ fg: T.text }}>{"  C                 Calendar-arm — arm this task + jump to the timeline\n"}</span>
+        <span style={{ fg: T.text }}>{"  C                 Copy task to clipboard (markdown line)\n"}</span>
         <span style={{ fg: T.textDim }}>{"\nTimeline scheduling\n"}</span>
-        <span style={{ fg: T.text }}>{"  C (any zone)       Arm the cursor task, then click a timeline slot to place it\n"}</span>
+        <span style={{ fg: T.text }}>{"  c (any zone)       Toggle ARM MODE — then click a task, click a slot, repeat\n"}</span>
         <span style={{ fg: T.text }}>{"  click empty row    Place the armed task here (30-min block, or move if it has one)\n"}</span>
         <span style={{ fg: T.text }}>{"  click band         Arm an existing block (or place the armed task at its start)\n"}</span>
         <span style={{ fg: T.text }}>{"  shift+click row    While armed (existing block): resize end to that row\n"}</span>
         <span style={{ fg: T.text }}>{"  j / k              While armed: nudge block ±15 min\n"}</span>
         <span style={{ fg: T.text }}>{"  + / -              While armed: resize block end ±15 min\n"}</span>
         <span style={{ fg: T.text }}>{"  Enter              While armed: commit + jump to source task\n"}</span>
-        <span style={{ fg: T.text }}>{"  Esc                Disarm\n"}</span>
+        <span style={{ fg: T.text }}>{"  Esc                Disarm / exit arm mode\n"}</span>
         <span style={{ fg: T.textDim }}>{"\nBoard-only actions\n"}</span>
         <span style={{ fg: T.text }}>{"  n                 New task in current column (quick-add syntax)\n"}</span>
         <span style={{ fg: T.text }}>{"  g                 Grab task — h/l then moves it between columns; g/Esc to drop\n"}</span>
         <span style={{ fg: T.text }}>{"  f                 Cycle board filter: all → today → overdue → tomorrow → followup\n"}</span>
         <span style={{ fg: T.text }}>{"  /                 Search task titles — jumps cursor to first match\n"}</span>
+        <span style={{ fg: T.textDim }}>{"\nAgents zone\n"}</span>
+        <span style={{ fg: T.text }}>{"  Enter             Open (resume) the selected session in a new WezTerm tab\n"}</span>
+        <span style={{ fg: T.text }}>{"  o                 Session detail (cwd, branch, last prompts, resume cmd)\n"}</span>
         <span style={{ fg: T.textDim }}>{"\nMulti-select\n"}</span>
         <span style={{ fg: T.text }}>{"  Space             Mark / unmark task — single-task actions then\n"}</span>
         <span style={{ fg: T.text }}>{"                    apply to ALL marked instead of just the cursor\n"}</span>

package/src/ui/TaskRow.tsx

@@ -12,7 +12,7 @@
 
 import { Show, createMemo } from "solid-js";
 
-import { PRIORITY_COLOR, PRIORITY_GLYPH, T, fmtMin } from "~/ui/glyphs";
+import { PRIORITY_COLOR, PRIORITY_GLYPH, T, cellWidth, fmtMin } from "~/ui/glyphs";
 import { isoToday, isoTomorrow } from "~/store/index";
 import type { Task } from "~/types";
 
@@ -71,7 +71,10 @@ export function TaskRow(props: TaskRowProps) {
     if (props.task.priority !== "none") overhead += 3; // emoji 2 cells + space
     if (props.contextTag) overhead += props.contextTag.length + 3; // " [" + tag + "]"
     const sfx = suffix();
-    if (sfx) overhead += sfx.length + 1; // leading space + suffix
+    // cellWidth (not .length) so the ⌚ time-block glyph — 2 cells but 1 code
+    // unit — is counted correctly. +1 leading space, +1 safety so the row can
+    // never exact-fit-overflow into OpenTUI's middle-ellipsis truncation.
+    if (sfx) overhead += cellWidth(sfx) + 2;
     const computed = props.availableWidth - overhead;
     return Math.max(6, Math.min(hardCap, computed));
   });

package/src/ui/TimelineView.tsx

@@ -83,6 +83,7 @@ export function TimelineView(props: TimelineViewProps) {
   const isActive = () => props.store.state.ui.activeZone === "timeline";
   const cursor = () => props.store.state.ui.row;
   const armedRef = () => props.store.state.ui.armedTimelineRef;
+  const armMode = () => props.store.state.ui.armMode;
 
   const entries = createMemo(() =>
     buildTimelineEntries(
@@ -215,6 +216,10 @@ export function TimelineView(props: TimelineViewProps) {
     if (!armed.timeBlock) {
       const startMin = Math.max(0, targetMin);
       const endMin = Math.min(24 * 60 - 1, startMin + DEFAULT_BLOCK_MIN);
+      // A time block only renders on the timeline when the task is also
+      // scheduled for today — so arming a task from ANY board and dropping it
+      // here pins it to today (otherwise it'd vanish: block set, wrong date).
+      props.store.setScheduled(ref, isoToday());
       props.store.setTimeBlock(ref, { startMin, endMin });
       props.store.flashBanner(
         "info",
@@ -262,13 +267,29 @@ export function TimelineView(props: TimelineViewProps) {
         marginLeft: 1,
         border: true,
         borderStyle: "rounded",
-        borderColor: isActive() ? T.borderActive : T.border,
+        // Arm mode paints the border warm so the special scheduling mode is
+        // unmistakable, even when the keyboard focus is elsewhere.
+        borderColor: armMode()
+          ? T.warmActive
+          : isActive()
+            ? T.borderActive
+            : T.border,
         paddingLeft: 1,
         paddingRight: 1,
       }}
-      title={`┤ Timeline · ${entries().length} ├`}
+      title={`┤ Timeline · ${entries().length}${armMode() ? "  ◉ ARM" : ""} ├`}
       titleAlignment="left"
     >
+      <Show when={armMode()}>
+        <text wrapMode="none">
+          <span style={{ fg: T.warmActive, attributes: ATTR.bold }}>
+            {"◉ ARM MODE "}
+          </span>
+          <span style={{ fg: T.textDim }}>
+            {"click a task → click a slot · Esc to exit"}
+          </span>
+        </text>
+      </Show>
       <Show when={armedTask()}>
         <text wrapMode="none">
           <span style={{ fg: T.warm, attributes: ATTR.bold }}>
@@ -315,6 +336,7 @@ export function TimelineView(props: TimelineViewProps) {
                 rowIndex={i()}
                 cursorEntry={isActive() ? cursorEntry() : undefined}
                 armedEntry={armedEntry()}
+                innerWidth={props.width ? props.width - 4 : undefined}
                 onBlockClick={onBlockClick}
                 onEmptyRowClick={onEmptyRowClick}
               />
@@ -361,6 +383,8 @@ interface TimelineRowProps {
   cursorEntry: TimelineEntry | undefined;
   /** When set, the armed entry — used to tint its rows warm. */
   armedEntry: TimelineEntry | undefined;
+  /** Panel content width (border+padding already removed). Undefined = fullscreen. */
+  innerWidth?: number;
   onBlockClick: (entry: TimelineEntry, event: MouseEventLike) => void;
   onEmptyRowClick: (rowIndex: number, event: MouseEventLike) => void;
 }
@@ -391,6 +415,15 @@ function TimelineRow(props: TimelineRowProps) {
   const rightIsArmed = () =>
     !!props.armedEntry && right().entry === props.armedEntry;
 
+  const leftIsDone = () => !!left().entry?.task.done;
+  const rightIsDone = () => !!right().entry?.task.done;
+
+  // Cell budget per lane, so RowContent can tail-truncate the title (keeping
+  // the head readable) instead of leaning on OpenTUI's middle-ellipsis.
+  const innerW = () => props.innerWidth ?? 200;
+  const splitLeftW = () => Math.floor((innerW() - 1) / 2);
+  const splitRightW = () => innerW() - 1 - splitLeftW();
+
   /** Mouse handler factory for a lane cell. */
   const cellMouseDown = (cellEntry: TimelineEntry | undefined) => {
     return (event: MouseEventLike) => {
@@ -416,12 +449,13 @@ function TimelineRow(props: TimelineRowProps) {
               leftIsCursor(),
               leftIsArmed(),
               leftIsBlock(),
+              leftIsDone(),
             ),
           }}
           onMouseDown={cellMouseDown(left().entry)}
         >
           <text wrapMode="none" truncate style={{ flexGrow: 1 }}>
-            <RowContent row={left()} rowIndex={props.rowIndex} />
+            <RowContent row={left()} rowIndex={props.rowIndex} laneWidth={innerW()} />
           </text>
         </box>
       }
@@ -443,12 +477,13 @@ function TimelineRow(props: TimelineRowProps) {
               leftIsCursor(),
               leftIsArmed(),
               leftIsBlock(),
+              leftIsDone(),
             ),
           }}
           onMouseDown={cellMouseDown(left().entry)}
         >
           <text wrapMode="none" truncate style={{ flexGrow: 1 }}>
-            <RowContent row={left()} rowIndex={props.rowIndex} />
+            <RowContent row={left()} rowIndex={props.rowIndex} laneWidth={splitLeftW()} />
           </text>
         </box>
         <text style={{ width: 1, flexShrink: 0 }} wrapMode="none">
@@ -464,13 +499,14 @@ function TimelineRow(props: TimelineRowProps) {
               rightIsCursor(),
               rightIsArmed(),
               rightIsBlock(),
+              rightIsDone(),
             ),
           }}
           onMouseDown={cellMouseDown(right().entry)}
         >
           <text wrapMode="none" truncate style={{ flexGrow: 1 }}>
             {/* Right lane skips the 3-char hour prefix that's already on the row. */}
-            <RowContent row={right()} rowIndex={props.rowIndex} skipPrefix />
+            <RowContent row={right()} rowIndex={props.rowIndex} laneWidth={splitRightW()} skipPrefix />
           </text>
         </box>
       </box>
@@ -483,6 +519,8 @@ interface RowContentProps {
   rowIndex: number;
   /** When true, omit the leading 3-char hour-gutter spacer. */
   skipPrefix?: boolean;
+  /** Cell budget for this lane — used to tail-truncate the block title. */
+  laneWidth?: number;
 }
 
 function RowContent(props: RowContentProps) {
@@ -552,12 +590,23 @@ function RowContent(props: RowContentProps) {
   if (r.kind === "body" && r.entry) {
     const e = r.entry;
     const bColor = boardColor(e.boardIndex);
+    // Tail-truncate so the START of the title stays readable (the head/tail
+    // ellipsis OpenTUI does otherwise chops the middle). Budget = lane width
+    // minus the prefix, the "│ " gutter, and the done check.
+    const avail = props.laneWidth ?? 200;
+    const budget = Math.max(
+      6,
+      avail - (props.skipPrefix ? 0 : 3) - 2 - (e.task.done ? 2 : 0),
+    );
     return (
       <>
         <span style={{ fg: T.textDim }}>{prefix}</span>
         <span style={{ fg: bColor }}>{"│ "}</span>
-        <span style={{ fg: e.task.done ? T.textDone : T.text }}>
-          {e.task.displayTitle}
+        <Show when={e.task.done}>
+          <span style={{ fg: T.done }}>{"✓ "}</span>
+        </Show>
+        <span style={{ fg: e.task.done ? T.done : T.text }}>
+          {tailTruncate(e.task.displayTitle, budget)}
         </span>
       </>
     );
@@ -614,10 +663,11 @@ function laneBg(
   isCursor: boolean,
   isArmed: boolean,
   isBlock: boolean,
+  isDone: boolean,
 ): string | undefined {
   if (isArmed) return T.warmDim;
   if (isCursor) return T.cardBgCursor;
-  if (isBlock) return T.cardBlockBg;
+  if (isBlock) return isDone ? T.cardBlockBgDone : T.cardBlockBg;
   return undefined;
 }
 

package/src/ui/VirtualPanel.tsx

@@ -119,6 +119,15 @@ export function VirtualPanel(props: { store: TuiStore }) {
             onClickItem={(flatIndex) => {
               props.store.setActiveZone("virtual");
               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).
+              if (props.store.state.ui.armMode) {
+                const item = items().find((it) => it.flatIndex === flatIndex);
+                if (item) {
+                  props.store.armTimeline(item.ref);
+                  props.store.setZoneVisible("timeline", true);
+                }
+              }
             }}
           />
         </scrollbox>

package/src/ui/glyphs.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test";
+
+import { cellWidth } from "~/ui/glyphs";
+
+describe("cellWidth", () => {
+  test("ASCII counts one cell per char", () => {
+    expect(cellWidth("09:00")).toBe(5);
+    expect(cellWidth("Costruire routine")).toBe(17);
+    expect(cellWidth("")).toBe(0);
+  });
+
+  test("the ⌚ time-block glyph is 2 cells (the bug that broke truncation)", () => {
+    expect(cellWidth("⌚")).toBe(2);
+    // The actual suffix on a time-blocked row: ⌚ + "09:00" = 2 + 5 = 7,
+    // not the 6 that String.length reports.
+    expect(cellWidth("⌚09:00")).toBe(7);
+    expect("⌚09:00".length).toBe(6); // proves the undercount we corrected
+  });
+
+  test("priority + clock emoji are 2 cells", () => {
+    expect(cellWidth("🔺")).toBe(2); // U+1F53A
+    expect(cellWidth("⏰")).toBe(2); // U+23F0
+    expect(cellWidth("⏫")).toBe(2); // U+23EB
+  });
+
+  test("narrow symbols used in rows stay 1 cell", () => {
+    expect(cellWidth("✓")).toBe(1); // done check
+    expect(cellWidth("●")).toBe(1); // marked dot
+    expect(cellWidth("→")).toBe(1); // tomorrow arrow
+  });
+});

package/src/ui/glyphs.ts

@@ -46,6 +46,9 @@ export const T = {
   // dotted/empty gutters around them. Just barely darker-than-cursor; on a
   // typical dark terminal it reads as "filled card", not as "highlighted".
   cardBlockBg: "#1c2030",
+  // Same idea but tinted faintly green for COMPLETED time blocks, matching
+  // the done-green title. Reads as "done" at a glance without shouting.
+  cardBlockBgDone: "#1a2a1d",
 
   // Foreground neutrals — readable mid-grays so dim chrome doesn't disappear
   text: undefined as string | undefined,    // terminal default fg
@@ -110,6 +113,26 @@ export function fmtMin(m: number): string {
   return `${h}:${mm}`;
 }
 
+// Symbols in the Misc-Technical block that render 2 cells wide despite being
+// a single JS code unit (so `.length` undercounts them): ⌚ ⏰ ⏫ ⏬ ⏩ ⏪.
+const WIDE_CODEPOINTS = new Set([0x231a, 0x231b, 0x23eb, 0x23ec, 0x23e9, 0x23ea, 0x23f0, 0x23f3]);
+
+/**
+ * Terminal display width of a string in cells, counting emoji / wide glyphs
+ * as 2. `.length` undercounts these (e.g. `⌚` is 1 code unit but 2 cells),
+ * which throws off truncation budgets and makes OpenTUI re-truncate a row
+ * with its middle-ellipsis. Use this wherever a layout budget must match what
+ * the terminal actually paints.
+ */
+export function cellWidth(s: string): number {
+  let w = 0;
+  for (const ch of s) {
+    const cp = ch.codePointAt(0)!;
+    w += cp >= 0x1f000 || WIDE_CODEPOINTS.has(cp) ? 2 : 1;
+  }
+  return w;
+}
+
 /**
  * Per-board accent palette. Used by the virtual panel to color-code the
  * source-board tag on priority/agenda items, so the user can recognize